Merge commit '389f0cff96936f5131180d06aa8a89cf1057389c' into merge-vulkan-1.1.121 am: a502b49145

am: 4b29c5338d

Change-Id: Id3a60f634304c83c4e3cd60990e34cf817c5c9d2

82 files changed, 19272 insertions, 9190 deletions

diff --git a/.appveyor.yml b/.appveyor.yml
index 1cdb9a30c..70390dba0 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -74,3 +74,7 @@ build:
   parallel: true                              # enable MSBuild parallel builds
   project: build/Vulkan-ValidationLayers.sln  # path to Visual Studio solution or project
   verbosity: quiet                            # quiet|minimal|normal|detailed
+
+artifacts:
+  - path: build\layers\$(configuration)
+    name: Vulkan-ValidationLayers-$(platform)-$(configuration)
diff --git a/BUILD.gn b/BUILD.gn
index 7acacb46c..ff08295cc 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -84,7 +84,6 @@ config("vulkan_layer_config") {
 core_validation_sources = [
   # This file is manually included in the layer
   # "layers/generated/vk_safe_struct.cpp",
-  "layers/generated/vk_safe_struct.h",
   "layers/buffer_validation.cpp",
   "layers/buffer_validation.h",
   "layers/core_validation.cpp",
@@ -121,41 +120,46 @@ thread_safety_sources = [
 unique_objects_sources = []
 
 chassis_sources = [
+  "layers/core_validation.h",
+  "layers/generated/vk_safe_struct.h",
+  "layers/generated/thread_safety.h",
   "layers/generated/chassis.cpp",
   "layers/generated/chassis.h",
   "layers/generated/layer_chassis_dispatch.cpp",
   "layers/generated/layer_chassis_dispatch.h",
+  "$vulkan_headers_dir/include/vulkan/vk_layer.h",
+  "$vulkan_headers_dir/include/vulkan/vulkan.h",
 ]
 
 layers = [
   [
     "core_validation",
-    core_validation_sources + chassis_sources,
+    core_validation_sources + chassis_sources + thread_safety_sources,
     [ ":vulkan_core_validation_glslang" ],
     [ "BUILD_CORE_VALIDATION" ],
   ],
   [
     "object_lifetimes",
-    object_lifetimes_sources + chassis_sources,
-    [],
+    object_lifetimes_sources + chassis_sources + thread_safety_sources + core_validation_sources,
+    [ ":vulkan_core_validation_glslang" ],
     [ "BUILD_OBJECT_TRACKER" ],
   ],
   [
     "stateless_validation",
-    stateless_validation_sources + chassis_sources,
-    [],
+    stateless_validation_sources + chassis_sources + core_validation_sources,
+    [ ":vulkan_core_validation_glslang" ],
     [ "BUILD_PARAMETER_VALIDATION" ],
   ],
   [
     "thread_safety",
-    thread_safety_sources + chassis_sources,
-    [],
+    thread_safety_sources + chassis_sources + core_validation_sources,
+    [ ":vulkan_core_validation_glslang" ],
     [ "BUILD_THREAD_SAFETY" ],
   ],
   [
     "unique_objects",
-    unique_objects_sources + chassis_sources,
-    [],
+    unique_objects_sources + chassis_sources + core_validation_sources,
+    [ ":vulkan_core_validation_glslang" ],
     [ "LAYER_CHASSIS_CAN_WRAP_HANDLES" ],
   ],
   [
@@ -192,6 +196,7 @@ if (!is_android) {
     ]
     sources = [
       "$vulkan_headers_dir/include/vulkan/vulkan_core.h",
+      "$vulkan_headers_dir/include/vulkan/vk_layer.h",
     ]
     outputs = []
     foreach(json_name, json_names) {
@@ -222,6 +227,9 @@ source_set("vulkan_layer_utils") {
     "layers/vk_layer_extension_utils.h",
     "layers/vk_layer_utils.cpp",
     "layers/vk_layer_utils.h",
+    "$vulkan_headers_dir/include/vulkan/vk_layer.h",
+    "$vulkan_headers_dir/include/vulkan/vulkan.h",
+    "$vulkan_headers_dir/include/vulkan/vk_sdk_platform.h",
   ]
   public_configs = [
     "$vulkan_headers_dir:vulkan_headers_config",
diff --git a/BUILD.md b/BUILD.md
index d164825c2..a974d7ad9 100644
--- a/BUILD.md
+++ b/BUILD.md
@@ -428,8 +428,8 @@ layer validation tests use the "googletest" testing framework.)
 ### Linux Build Requirements
 
 This repository has been built and tested on the two most recent Ubuntu LTS
-versions. Currently, the oldest supported version is Ubuntu 14.04, meaning
-that the minimum supported compiler versions are GCC 4.8.2 and Clang 3.4,
+versions. Currently, the oldest supported version is Ubuntu 16.04, meaning
+that the minimum officially supported C++11 compiler version is GCC 5.4.0,
 although earlier versions may work. It should be straightforward to adapt this
 repository to other Linux distributions.
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1f9b71005..b1ce624c9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -309,12 +309,12 @@ endif()
 install(TARGETS VkLayer_utils DESTINATION ${CMAKE_INSTALL_LIBDIR})
 set_target_properties(VkLayer_utils PROPERTIES LINKER_LANGUAGE CXX)
 target_include_directories(VkLayer_utils
-                           PUBLIC ${VulkanHeaders_INCLUDE_DIR}
-                                  ${CMAKE_CURRENT_SOURCE_DIR}/layers
+                           PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/layers
                                   ${CMAKE_CURRENT_SOURCE_DIR}/layers/generated
                                   ${CMAKE_CURRENT_BINARY_DIR}
                                   ${CMAKE_CURRENT_BINARY_DIR}/layers
-                                  ${PROJECT_BINARY_DIR})
+                                  ${PROJECT_BINARY_DIR}
+                                  ${VulkanHeaders_INCLUDE_DIR})
 
 # uninstall target ---------------------------------------------------------------------------------------------------------------
 if(NOT TARGET uninstall)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c3afe2568..bca881c7e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -77,7 +77,7 @@ a good reason is "This violates the style guide, but it improves type safety."
 >        $ git commit
 
 * **Commit Messages**
-    * Limit the subject line to 50 characters -- this allows the information to display correctly in git/Github logs
+    * Limit the subject line to 64 characters -- this allows the information to display correctly in git/GitHub logs
     * Begin subject line with a one-word component description followed by a colon (e.g. build, docs, layers, tests, etc.)
     * Separate subject from body with a blank line
     * Wrap the body at 72 characters
@@ -92,7 +92,7 @@ that to be accepted into the repository, the pull request must [pass all tests](
 -- the automatic Github Travis and AppVeyor continuous integration features will assist in enforcing this requirement.
 
 #### **Testing Your Changes**
-* Run the existing tests in the repository before and after each if your commits to check for any regressions.
+* Run the existing tests in the repository before and after each of your commits to check for any regressions.
   There are some tests that appear in all repositories.
   These tests can be found in the following folders inside of your target build directory:
 
diff --git a/build-android/cmake/layerlib/CMakeLists.txt b/build-android/cmake/layerlib/CMakeLists.txt
index 5321a0430..2e59ecd5e 100644
--- a/build-android/cmake/layerlib/CMakeLists.txt
+++ b/build-android/cmake/layerlib/CMakeLists.txt
@@ -155,7 +155,7 @@ target_link_libraries(VkLayer_object_tracker PRIVATE log layer_utils)
 add_library(VkLayer_threading SHARED
         ${COMMON_DIR}/include/thread_safety.cpp
         ${COMMON_DIR}/include/layer_chassis_dispatch.cpp
-        ${COMMON_DIR}/include/chassis.cpp
+        ${COMMON_DIR}/include/chassis.cpp)
 target_compile_definitions(VkLayer_threading PUBLIC "BUILD_THREAD_SAFETY")
 target_include_directories(VkLayer_threading PRIVATE
         ${SRC_DIR}/include
@@ -165,7 +165,7 @@ target_include_directories(VkLayer_threading PRIVATE
 target_link_libraries(VkLayer_threading PRIVATE log layer_utils)
 
 add_library(VkLayer_unique_objects SHARED
-        ${COMMON_DIR}/include/layer_chassis_dispatch.cpp)
+        ${COMMON_DIR}/include/layer_chassis_dispatch.cpp
         ${COMMON_DIR}/include/chassis.cpp)
 target_compile_definitions(VkLayer_object_tracker PUBLIC "LAYER_CHASSIS_CAN_WRAP_HANDLES")
 target_include_directories(VkLayer_unique_objects PRIVATE
diff --git a/build-android/known_good.json b/build-android/known_good.json
index 610f286fd..dac58e97f 100644
--- a/build-android/known_good.json
+++ b/build-android/known_good.json
@@ -10,31 +10,31 @@
       "name" : "glslang",
       "url" : "https://github.com/KhronosGroup/glslang.git",
       "sub_dir" : "shaderc/third_party/glslang",
-      "commit" : "21eebe74214488264bbf0d19323a03c13a9e53a7"
+      "commit" : "74426f7570fdd23a3bcf7ac0987347197f44c92e"
     },
     {
       "name" : "Vulkan-Headers",
       "url" : "https://github.com/KhronosGroup/Vulkan-Headers.git",
       "sub_dir" : "Vulkan-Headers",
-      "commit" : "v1.1.114"
+      "commit" : "v1.1.121"
     },
     {
       "name" : "Vulkan-Tools",
       "url" : "https://github.com/KhronosGroup/Vulkan-Tools.git",
       "sub_dir" : "Vulkan-Tools",
-      "commit" : "v1.1.114"
+      "commit" : "e36c760bbde1c56b5b2a934347ff0fb9dce4d793"
     },
     {
       "name" : "SPIRV-Tools",
       "url" : "https://github.com/KhronosGroup/SPIRV-Tools.git",
       "sub_dir" : "shaderc/third_party/spirv-tools",
-      "commit" : "d01a3c3b4b76e942e1c22adca5a9713197dde901"
+      "commit" : "1fedf72e500b7cf72098a3f800c8ef4b9d9dc84f"
     },
     {
       "name" : "SPIRV-Headers",
       "url" : "https://github.com/KhronosGroup/SPIRV-Headers.git",
       "sub_dir" : "shaderc/third_party/spirv-tools/external/spirv-headers",
-      "commit" : "8b911bd2ba37677037b38c9bd286c7c05701bcda"
+      "commit" : "dcce859e34cf0c23625ec75ac44df750aa2f4d70"
     }
   ]
 }
diff --git a/build-android/test_APK.sh b/build-android/test_APK.sh
index 53469e0cb..b51dafbeb 100755
--- a/build-android/test_APK.sh
+++ b/build-android/test_APK.sh
@@ -251,7 +251,9 @@ adb $serialFlag shell am force-stop com.example.VulkanLayerValidationTests
 echo
 echo Fetching test output and filtered logcat text...
 
-today=$(date +%Y-%m-%d.%H:%M:%S)
+# Avoid characters that are illegal in Windows filenames, so these
+# files can be archived to a Windows host system for later reference
+today=$(date +%Y%m%d-%H%M%S)
 outFile="VulkanLayerValidationTests.$platform.$today.out.txt"
 errFile="VulkanLayerValidationTests.$platform.$today.err.txt"
 logFile="VulkanLayerValidationTests.$platform.$today.logcat.txt"
diff --git a/docs/gpu_validation.md b/docs/gpu_validation.md
index 3b73ce2c2..99520d9cf 100644
--- a/docs/gpu_validation.md
+++ b/docs/gpu_validation.md
@@ -87,6 +87,8 @@ array elements, those elements are not required to have been written.
 The instrumentation code needs to know which elements of a descriptor array have been written, so that it can tell if one is used
 that has not been written.
 
+Note that currently, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT validation is not working and all accesses are reported as valid.
+
 
 ## GPU-Assisted Validation Options
 
@@ -256,7 +258,7 @@ It isn't necessarily required for using the feature.
 
 In general, the implementation does:
 
-* For each draw call, allocate a buffer with enough device memory to hold a single debug output record written by the
+* For each draw, dispatch, and trace rays call, allocate a buffer with enough device memory to hold a single debug output record written by the
     instrumented shader code.
     If descriptor indexing is enabled, calculate the amount of memory needed to describe the descriptor arrays sizes and
     write states and allocate device memory and a buffer for input to the instrumented shader.
@@ -271,7 +273,7 @@ In general, the implementation does:
     An alternative design allocates this block on a per-device or per-queue basis and should work.
     However, it is not possible to identify the command buffer that causes the error if multiple command buffers
     are submitted at once.
-* For each draw call, allocate a descriptor set and update it to point to the block of device memory just allocated.
+* For each draw, dispatch, and trace rays call, allocate a descriptor set and update it to point to the block of device memory just allocated.
     If descriptor indexing is enabled, also update the descriptor set to point to the allocated input buffer.
     Fill the input buffer with the size and write state information for each descriptor array.
     There is a descriptor set manager to handle this efficiently.
@@ -297,13 +299,13 @@ In general, the implementation does:
     Instead, the layer leaves the layout alone and later replaces the instrumented shaders with
     non-instrumented ones when the pipeline layout is later used to create a graphics pipeline.
     The layer issues an error message to report this condition.
-* When creating a GraphicsPipeline, check to see if the pipeline is using the debug binding index.
+* When creating a GraphicsPipeline, ComputePipeline, or RayTracingPipeline, check to see if the pipeline is using the debug binding index.
     If it is, replace the instrumented shaders in the pipeline with non-instrumented ones.
 * Before calling QueueSubmit, if descriptor indexing is enabled, check to see if there were any unwritten descriptors that were declared
     update-after-bind.
     If there were, update the write state of those elements.
 * After calling QueueSubmit, perform a wait on the queue to allow the queue to finish executing.
-    Then map and examine the device memory block for each draw that was submitted.
+    Then map and examine the device memory block for each draw or trace ray command that was submitted.
     If any debug record is found, generate a validation error message for each record found.
 
 The above describes only the high-level details of GPU-Assisted Validation operation.
@@ -426,7 +428,7 @@ The design of each hooked function follows:
 
 #### GpuAllocateValidationResources
 
-* For each Draw or Dispatch call:
+* For each Draw, Dispatch, or TraceRays call:
   * Get a descriptor set from the descriptor set manager
   * Get an output buffer and associated memory from VMA
   * If descriptor indexing is enabled, get an input buffer and fill with descriptor array information
@@ -434,7 +436,7 @@ The design of each hooked function follows:
   * Check to see if the layout for the pipeline just bound is using our selected bind index
   * If no conflict, add an additional command to the command buffer to bind our descriptor set at our selected index
 * Record the above objects in the per-CB state
-Note that the Draw and Dispatch calls include vkCmdDraw, vkCmdDrawIndexed, vkCmdDrawIndirect, vkCmdDrawIndexedIndirect, vkCmdDispatch, and vkCmdDispatchIndirect.
+Note that the Draw and Dispatch calls include vkCmdDraw, vkCmdDrawIndexed, vkCmdDrawIndirect, vkCmdDrawIndexedIndirect, vkCmdDispatch, vkCmdDispatchIndirect, and vkCmdTraceRaysNV.
 
 #### GpuPreCallRecordFreeCommandBuffers
 
@@ -653,29 +655,41 @@ The Instruction Index is the instruction within the original function at which t
 For bindless, this will be the instruction which consumes the descriptor in question,
 or the instruction that consumes the OpSampledImage that consumes the descriptor.
 
-The Stage is the integer value used in SPIR-V for each of the Graphics Execution Models:
-
-| Stage  | Value |
-|--------|:-----:|
-|Vertex  |0      |
-|TessCtrl|1      |
-|TessEval|2      |
-|Geometry|3      |
-|Fragment|4      |
-|Compute |5      |
+The Stage is the integer value used in SPIR-V for each of the Execution Models:
+
+| Stage         | Value |
+|---------------|:-----:|
+|Vertex         |0      |
+|TessCtrl       |1      |
+|TessEval       |2      |
+|Geometry       |3      |
+|Fragment       |4      |
+|Compute        |5      |
+|RayGenerationNV|5313   |
+|IntersectionNV |5314   |
+|AnyHitNV       |5315   |
+|ClosestHitNV   |5316   |
+|MissNV         |5317   |
+|CallableNV     |5318   |
 
 ### Stage Specific Words
 
 These are words that identify which "instance" of the shader the validation error occurred in.
 Here are words for each stage:
 
-| Stage  | Word 0           | Word 1     |
-|--------|------------------|------------|
-|Vertex  |VertexID          |InstanceID  |
-|Tess*   |InvocationID      |unused      |
-|Geometry|PrimitiveID       |InvocationID|
-|Fragment|FragCoord.x       |FragCoord.y |
-|Compute |GlobalInvocationID|unused      |
+| Stage         | Word 0           | Word 1     | World 2    |
+|---------------|------------------|------------|------------|
+|Vertex         |VertexID          |InstanceID  | unused     |
+|Tess*          |InvocationID      |unused      | unused     |
+|Geometry       |PrimitiveID       |InvocationID| unused     |
+|Fragment       |FragCoord.x       |FragCoord.y | unused     |
+|Compute        |GlobalInvocationID|unused      | unused     |
+|RayGenerationNV|LaunchIdNV.x      |LaunchIdNV.y|LaunchIdNV.z|
+|IntersectionNV |LaunchIdNV.x      |LaunchIdNV.y|LaunchIdNV.z|
+|AnyHitNV       |LaunchIdNV.x      |LaunchIdNV.y|LaunchIdNV.z|
+|ClosestHitNV   |LaunchIdNV.x      |LaunchIdNV.y|LaunchIdNV.z|
+|MissNV         |LaunchIdNV.x      |LaunchIdNV.y|LaunchIdNV.z|
+|CallableNV     |LaunchIdNV.x      |LaunchIdNV.y|LaunchIdNV.z|
 
 "unused" means not relevant, but still present.
 
diff --git a/external/x64/lib/vulkan-1.lib b/external/x64/lib/vulkan-1.lib
new file mode 100644
index 000000000..3e23a7bcf
--- /dev/null
+++ b/external/x64/lib/vulkan-1.lib
diff --git a/external/x86/lib/vulkan-1.lib b/external/x86/lib/vulkan-1.lib
new file mode 100644
index 000000000..3caa7ba04
--- /dev/null
+++ b/external/x86/lib/vulkan-1.lib
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 5541816d3..c908ffc1a 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -142,7 +142,7 @@ else(UNIX AND NOT APPLE) # i.e.: Linux
     endmacro()
 endif()
 
-include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${VulkanHeaders_INCLUDE_DIR})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/generated ${VulkanHeaders_INCLUDE_DIR})
 
 if(WIN32)
     # Applies to all configurations
@@ -192,6 +192,10 @@ set(STATELESS_VALIDATION_LIBRARY_FILES
     generated/parameter_validation.h
     parameter_validation_utils.cpp)
 
+set(BEST_PRACTICES_LIBRARY_FILES
+    best_practices.cpp
+    best_practices.h)
+
 if(BUILD_LAYERS)
     AddVkLayer(core_validation "BUILD_CORE_VALIDATION"
         ${CHASSIS_LIBRARY_FILES}
@@ -200,12 +204,13 @@ if(BUILD_LAYERS)
     AddVkLayer(thread_safety "BUILD_THREAD_SAFETY" ${CHASSIS_LIBRARY_FILES} ${THREAD_SAFETY_LIBRARY_FILES})
     AddVkLayer(stateless_validation "BUILD_PARAMETER_VALIDATION" ${CHASSIS_LIBRARY_FILES} ${STATELESS_VALIDATION_LIBRARY_FILES})
     AddVkLayer(unique_objects "LAYER_CHASSIS_CAN_WRAP_HANDLES" ${CHASSIS_LIBRARY_FILES})
-    AddVkLayer(khronos_validation "BUILD_KHRONOS_VALIDATION;BUILD_CORE_VALIDATION;BUILD_OBJECT_TRACKER;BUILD_THREAD_SAFETY;BUILD_PARAMETER_VALIDATION;LAYER_CHASSIS_CAN_WRAP_HANDLES"
+    AddVkLayer(khronos_validation "BUILD_KHRONOS_VALIDATION;BUILD_CORE_VALIDATION;BUILD_OBJECT_TRACKER;BUILD_THREAD_SAFETY;BUILD_PARAMETER_VALIDATION;LAYER_CHASSIS_CAN_WRAP_HANDLES;BUILD_BEST_PRACTICES"
         ${CHASSIS_LIBRARY_FILES}
         ${CORE_VALIDATION_LIBRARY_FILES}
         ${OBJECT_LIFETIMES_LIBRARY_FILES}
         ${THREAD_SAFETY_LIBRARY_FILES}
-        ${STATELESS_VALIDATION_LIBRARY_FILES})
+        ${STATELESS_VALIDATION_LIBRARY_FILES}
+        ${BEST_PRACTICES_LIBRARY_FILES})
 
     # Core validation and Khronos validation have additional dependencies
     target_include_directories(VkLayer_core_validation PRIVATE ${GLSLANG_SPIRV_INCLUDE_DIR})
diff --git a/layers/best_practices.cpp b/layers/best_practices.cpp
new file mode 100644
index 000000000..85d1dc35a
--- /dev/null
+++ b/layers/best_practices.cpp
@@ -0,0 +1,393 @@
+/* Copyright (c) 2015-2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2019 Valve Corporation
+ * Copyright (c) 2015-2019 LunarG, 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: Camden Stocker <camden@lunarg.com>
+ */
+
+#include "best_practices.h"
+#include "layer_chassis_dispatch.h"
+
+#include <string>
+#include <iomanip>
+
+// get the API name is proper format
+std::string BestPractices::GetAPIVersionName(uint32_t version) {
+    std::stringstream version_name;
+    uint32_t major = VK_VERSION_MAJOR(version);
+    uint32_t minor = VK_VERSION_MINOR(version);
+    uint32_t patch = VK_VERSION_PATCH(version);
+
+    version_name << major << "." << minor << "." << patch << " (0x" << std::setfill('0') << std::setw(8) << std::hex << version
+                 << ")";
+
+    return version_name.str();
+}
+
+bool BestPractices::PreCallValidateCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                                  VkInstance* pInstance) {
+    bool skip = false;
+
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
+        if (white_list(pCreateInfo->ppEnabledExtensionNames[i], kDeviceExtensionNames)) {
+            skip |=
+                log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(), "vkCreateInstance(): Attempting to enable Device Extension %s at CreateInstance time.",
+                        pCreateInfo->ppEnabledExtensionNames[i]);
+        }
+    }
+
+    return skip;
+}
+
+void BestPractices::PreCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                                VkInstance* pInstance) {
+    instance_api_version = pCreateInfo->pApplicationInfo->apiVersion;
+}
+
+bool BestPractices::PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
+                                                const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
+    bool skip = false;
+
+    // get API version of physical device passed when creating device.
+    VkPhysicalDeviceProperties physical_device_properties{};
+    DispatchGetPhysicalDeviceProperties(physicalDevice, &physical_device_properties);
+    device_api_version = physical_device_properties.apiVersion;
+
+    // check api versions and warn if instance api Version is higher than version on device.
+    if (instance_api_version > device_api_version) {
+        std::string inst_api_name = GetAPIVersionName(instance_api_version);
+        std::string dev_api_name = GetAPIVersionName(device_api_version);
+
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                    "vkCreateDevice(): API Version of current instance, %s is higher than API Version on device, %s",
+                    inst_api_name.c_str(), dev_api_name.c_str());
+    }
+
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
+        if (white_list(pCreateInfo->ppEnabledExtensionNames[i], kInstanceExtensionNames)) {
+            skip |=
+                log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(), "vkCreateDevice(): Attempting to enable Instance Extension %s at CreateDevice time.",
+                        pCreateInfo->ppEnabledExtensionNames[i]);
+        }
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+                                                const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
+    bool skip = false;
+
+    if ((pCreateInfo->queueFamilyIndexCount > 1) && (pCreateInfo->sharingMode == VK_SHARING_MODE_EXCLUSIVE)) {
+        std::stringstream bufferHex;
+        bufferHex << "0x" << std::hex << HandleToUint64(pBuffer);
+
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                    "Warning: Buffer (%s) specifies a sharing mode of VK_SHARING_MODE_EXCLUSIVE while specifying multiple queues "
+                    "(queueFamilyIndexCount of %" PRIu32 ").",
+                    bufferHex.str().c_str(), pCreateInfo->queueFamilyIndexCount);
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo,
+                                               const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
+    bool skip = false;
+
+    if ((pCreateInfo->queueFamilyIndexCount > 1) && (pCreateInfo->sharingMode == VK_SHARING_MODE_EXCLUSIVE)) {
+        std::stringstream imageHex;
+        imageHex << "0x" << std::hex << HandleToUint64(pImage);
+
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                    "Warning: Image (%s) specifies a sharing mode of VK_SHARING_MODE_EXCLUSIVE while specifying multiple queues "
+                    "(queueFamilyIndexCount of %" PRIu32 ").",
+                    imageHex.str().c_str(), pCreateInfo->queueFamilyIndexCount);
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) {
+    bool skip = false;
+
+    if ((pCreateInfo->queueFamilyIndexCount > 1) && (pCreateInfo->imageSharingMode == VK_SHARING_MODE_EXCLUSIVE)) {
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                    "Warning: A Swapchain is being created which specifies a sharing mode of VK_SHARING_MODE_EXCULSIVE while "
+                    "specifying multiple queues (queueFamilyIndexCount of %" PRIu32 ").",
+                    pCreateInfo->queueFamilyIndexCount);
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                             const VkSwapchainCreateInfoKHR* pCreateInfos,
+                                                             const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) {
+    bool skip = false;
+
+    for (uint32_t i = 0; i < swapchainCount; i++) {
+        if ((pCreateInfos[i].queueFamilyIndexCount > 1) && (pCreateInfos[i].imageSharingMode == VK_SHARING_MODE_EXCLUSIVE)) {
+            skip |= log_msg(
+                report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                "Warning: A shared swapchain (index %" PRIu32
+                ") is being created which specifies a sharing mode of VK_SHARING_MODE_EXCLUSIVE while specifying multiple "
+                "queues (queueFamilyIndexCount of %" PRIu32 ").",
+                i, pCreateInfos[i].queueFamilyIndexCount);
+        }
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+                                                    const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    bool skip = false;
+
+    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+        VkFormat format = pCreateInfo->pAttachments[i].format;
+        if (pCreateInfo->pAttachments[i].initialLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
+            if ((FormatIsColor(format) || FormatHasDepth(format)) &&
+                pCreateInfo->pAttachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                layer_name.c_str(),
+                                "Render pass has an attachment with loadOp == VK_ATTACHMENT_LOAD_OP_LOAD and "
+                                "initialLayout == VK_IMAGE_LAYOUT_UNDEFINED.  This is probably not what you "
+                                "intended.  Consider using VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the "
+                                "image truely is undefined at the start of the render pass.");
+            }
+            if (FormatHasStencil(format) && pCreateInfo->pAttachments[i].stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                layer_name.c_str(),
+                                "Render pass has an attachment with stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD "
+                                "and initialLayout == VK_IMAGE_LAYOUT_UNDEFINED.  This is probably not what you "
+                                "intended.  Consider using VK_ATTACHMENT_LOAD_OP_DONT_CARE instead if the "
+                                "image truely is undefined at the start of the render pass.");
+            }
+        }
+    }
+
+    for (uint32_t dependency = 0; dependency < pCreateInfo->dependencyCount; dependency++) {
+        skip |= CheckPipelineStageFlags("vkCreateRenderPass", pCreateInfo->pDependencies[dependency].srcStageMask);
+        skip |= CheckPipelineStageFlags("vkCreateRenderPass", pCreateInfo->pDependencies[dependency].dstStageMask);
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                                  const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+    bool skip = false;
+
+    num_mem_objects++;
+
+    if (num_mem_objects > kMemoryObjectWarningLimit) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(), "Performance Warning: This app has > %" PRIu32 " memory objects.",
+                        kMemoryObjectWarningLimit);
+    }
+
+    return skip;
+}
+
+void BestPractices::PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+    if (memory != VK_NULL_HANDLE) {
+        num_mem_objects--;
+    }
+}
+
+bool BestPractices::PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                                           const VkGraphicsPipelineCreateInfo* pCreateInfos,
+                                                           const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    bool skip = false;
+
+    if ((createInfoCount > 1) && (!pipelineCache)) {
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                    layer_name.c_str(),
+                    "Performance Warning: This vkCreateGraphicsPipelines call is creating multiple pipelines but is not using a "
+                    "pipeline cache, which may help with performance");
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                                          const VkComputePipelineCreateInfo* pCreateInfos,
+                                                          const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
+    bool skip = false;
+
+    if ((createInfoCount > 1) && (!pipelineCache)) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(),
+                        "Performance Warning: This vkCreateComputePipelines call is creating multiple pipelines but is not using a "
+                        "pipeline cache, which may help with performance");
+    }
+
+    return skip;
+}
+
+bool BestPractices::CheckPipelineStageFlags(std::string api_name, const VkPipelineStageFlags flags) {
+    bool skip = false;
+
+    if (flags & VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT) {
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                    "You are using VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT when %s is called\n", api_name.c_str());
+    } else if (flags & VK_PIPELINE_STAGE_ALL_COMMANDS_BIT) {
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                    "You are using VK_PIPELINE_STAGE_ALL_COMMANDS_BIT when %s is called\n", api_name.c_str());
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) {
+    bool skip = false;
+
+    for (uint32_t submit = 0; submit < submitCount; submit++) {
+        for (uint32_t semaphore = 0; semaphore < pSubmits[submit].waitSemaphoreCount; semaphore++) {
+            skip |= CheckPipelineStageFlags("vkQueueSubmit", pSubmits[submit].pWaitDstStageMask[semaphore]);
+        }
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    bool skip = false;
+
+    skip |= CheckPipelineStageFlags("vkCmdSetEvent", stageMask);
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+    bool skip = false;
+
+    skip |= CheckPipelineStageFlags("vkCmdResetEvent", stageMask);
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                                 VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
+                                                 uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                                 uint32_t bufferMemoryBarrierCount,
+                                                 const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                                 uint32_t imageMemoryBarrierCount,
+                                                 const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    bool skip = false;
+
+    skip |= CheckPipelineStageFlags("vkCmdWaitEvents", srcStageMask);
+    skip |= CheckPipelineStageFlags("vkCmdWaitEvents", dstStageMask);
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
+                                                      VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
+                                                      uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                                      uint32_t bufferMemoryBarrierCount,
+                                                      const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                                      uint32_t imageMemoryBarrierCount,
+                                                      const VkImageMemoryBarrier* pImageMemoryBarriers) {
+    bool skip = false;
+
+    skip |= CheckPipelineStageFlags("vkCmdPipelineBarrier", srcStageMask);
+    skip |= CheckPipelineStageFlags("vkCmdPipelineBarrier", dstStageMask);
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                                     VkQueryPool queryPool, uint32_t query) {
+    bool skip = false;
+
+    skip |= CheckPipelineStageFlags("vkCmdWriteTimestamp", pipelineStage);
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
+                                           uint32_t firstVertex, uint32_t firstInstance) {
+    bool skip = false;
+
+    if (instanceCount == 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(), "Warning: You are calling vkCmdDraw() with an instanceCount of Zero.");
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
+                                                  uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+    bool skip = false;
+
+    if (instanceCount == 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(), "Warning: You are calling vkCmdDrawIndexed() with an instanceCount of Zero.");
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                   uint32_t drawCount, uint32_t stride) {
+    bool skip = false;
+
+    if (drawCount == 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(), "Warning: You are calling vkCmdDrawIndirect() with a drawCount of Zero.");
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                          uint32_t drawCount, uint32_t stride) {
+    bool skip = false;
+
+    if (drawCount == 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        layer_name.c_str(), "Warning: You are calling vkCmdDrawIndexedIndirect() with a drawCount of Zero.");
+    }
+
+    return skip;
+}
+
+bool BestPractices::PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                               uint32_t groupCountZ) {
+    bool skip = false;
+
+    if ((groupCountX == 0) || (groupCountY == 0) || (groupCountZ == 0)) {
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, layer_name.c_str(),
+                    "Warning: You are calling vkCmdDispatch() while one or more groupCounts are zero (groupCountX = %" PRIu32
+                    ", groupCountY = %" PRIu32 ", groupCountZ = %" PRIu32 ").",
+                    groupCountX, groupCountY, groupCountZ);
+    }
+
+    return skip;
+}
diff --git a/layers/best_practices.h b/layers/best_practices.h
new file mode 100644
index 000000000..394716ab7
--- /dev/null
+++ b/layers/best_practices.h
@@ -0,0 +1,90 @@
+/* Copyright (c) 2015-2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2019 Valve Corporation
+ * Copyright (c) 2015-2019 LunarG, 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: Camden Stocker <camden@lunarg.com>
+ */
+
+#pragma once
+
+#include "chassis.h"
+#include <string>
+
+static const uint32_t kMemoryObjectWarningLimit = 250;
+
+class BestPractices : public ValidationObject {
+   public:
+    std::string GetAPIVersionName(uint32_t version);
+
+    bool PreCallValidateCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                       VkInstance* pInstance);
+    void PreCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                     VkInstance* pInstance);
+    bool PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo,
+                                     const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+    bool PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
+                                     const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+    bool PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                    VkImage* pImage);
+    bool PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
+                                           const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
+    bool PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                  const VkSwapchainCreateInfoKHR* pCreateInfos,
+                                                  const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
+    bool PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+                                         const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+    bool PreCallValidateAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
+                                       const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+    void PreCallRecordFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
+    bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                                const VkGraphicsPipelineCreateInfo* pCreateInfos,
+                                                const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+    bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount,
+                                               const VkComputePipelineCreateInfo* pCreateInfos,
+                                               const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+
+    bool CheckPipelineStageFlags(std::string api_name, const VkPipelineStageFlags flags);
+    bool PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
+    bool PreCallValidateCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+    bool PreCallValidateCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+    bool PreCallValidateCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents,
+                                      VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
+                                      uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                      uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                      uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+    bool PreCallValidateCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
+                                           VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
+                                           uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
+                                           uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+                                           uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+    bool PreCallValidateCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
+                                          VkQueryPool queryPool, uint32_t query);
+    bool PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
+                                uint32_t firstInstance);
+    bool PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
+                                       uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+    bool PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount,
+                                        uint32_t stride);
+    bool PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                               uint32_t drawCount, uint32_t stride);
+    bool PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY,
+                                    uint32_t groupCountZ);
+
+   private:
+    uint32_t instance_api_version;
+    uint32_t device_api_version;
+
+    uint32_t num_mem_objects;
+};
diff --git a/layers/buffer_validation.cpp b/layers/buffer_validation.cpp
index 8340d037d..4e16e8e63 100644
--- a/layers/buffer_validation.cpp
+++ b/layers/buffer_validation.cpp
@@ -29,6 +29,7 @@
 #include <string>
 
 #include "vk_enum_string_helper.h"
+#include "vk_format_utils.h"
 #include "vk_layer_data.h"
 #include "vk_layer_utils.h"
 #include "vk_layer_logging.h"
@@ -113,6 +114,8 @@ IMAGE_VIEW_STATE::IMAGE_VIEW_STATE(const IMAGE_STATE *image_state, VkImageView i
 
         // Cache a full normalization (for "full image/whole image" comparisons)
         normalized_subresource_range = NormalizeSubresourceRange(*image_state, ci->subresourceRange);
+        samples = image_state->createInfo.samples;
+        descriptor_format_bits = DescriptorRequirementsBitsFromFormat(create_info.format);
     }
 }
 
@@ -174,8 +177,7 @@ void CoreChecks::SetLayout(OBJECT *pObject, ImageSubresourcePair imgpair, const
 }
 
 // Set the layout in supplied map
-void CoreChecks::SetLayout(std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> &imageLayoutMap,
-                           ImageSubresourcePair imgpair, VkImageLayout layout) {
+void CoreChecks::SetLayout(ImageSubresPairLayoutMap &imageLayoutMap, ImageSubresourcePair imgpair, VkImageLayout layout) {
     auto it = imageLayoutMap.find(imgpair);
     if (it != imageLayoutMap.end()) {
         it->second.layout = layout;  // Update
@@ -246,8 +248,8 @@ bool CoreChecks::FindLayouts(VkImage image, std::vector<VkImageLayout> &layouts)
     return true;
 }
 
-bool CoreChecks::FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> &imageLayoutMap,
-                            ImageSubresourcePair imgpair, VkImageLayout &layout, const VkImageAspectFlags aspectMask) {
+bool CoreChecks::FindLayout(const ImageSubresPairLayoutMap &imageLayoutMap, ImageSubresourcePair imgpair, VkImageLayout &layout,
+                            const VkImageAspectFlags aspectMask) {
     if (!(imgpair.subresource.aspectMask & aspectMask)) {
         return false;
     }
@@ -261,8 +263,8 @@ bool CoreChecks::FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE
 }
 
 // find layout in supplied map
-bool CoreChecks::FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> &imageLayoutMap,
-                            ImageSubresourcePair imgpair, VkImageLayout &layout) {
+bool CoreChecks::FindLayout(const ImageSubresPairLayoutMap &imageLayoutMap, ImageSubresourcePair imgpair,
+                            VkImageLayout &layout) const {
     layout = VK_IMAGE_LAYOUT_MAX_ENUM;
     FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_COLOR_BIT);
     FindLayout(imageLayoutMap, imgpair, layout, VK_IMAGE_ASPECT_DEPTH_BIT);
@@ -312,6 +314,9 @@ void CoreChecks::SetImageLayout(CMD_BUFFER_STATE *cb_node, const IMAGE_STATE &im
 
 // Set the initial image layout for all slices of an image view
 void CoreChecks::SetImageViewInitialLayout(CMD_BUFFER_STATE *cb_node, const IMAGE_VIEW_STATE &view_state, VkImageLayout layout) {
+    if (disabled.image_layout_validation) {
+        return;
+    }
     IMAGE_STATE *image_state = GetImageState(view_state.create_info.image);
     if (image_state) {
         auto *subresource_map = GetImageSubresourceLayoutMap(cb_node, *image_state);
@@ -358,7 +363,7 @@ void CoreChecks::SetImageViewLayout(CMD_BUFFER_STATE *cb_node, const IMAGE_VIEW_
 bool CoreChecks::ValidateRenderPassLayoutAgainstFramebufferImageUsage(RenderPassCreateVersion rp_version, VkImageLayout layout,
                                                                       VkImage image, VkImageView image_view,
                                                                       VkFramebuffer framebuffer, VkRenderPass renderpass,
-                                                                      uint32_t attachment_index, const char *variable_name) {
+                                                                      uint32_t attachment_index, const char *variable_name) const {
     bool skip = false;
     auto image_state = GetImageState(image);
     const char *vuid;
@@ -454,12 +459,13 @@ bool CoreChecks::ValidateRenderPassLayoutAgainstFramebufferImageUsage(RenderPass
     return skip;
 }
 
-bool CoreChecks::VerifyFramebufferAndRenderPassLayouts(RenderPassCreateVersion rp_version, CMD_BUFFER_STATE *pCB,
+bool CoreChecks::VerifyFramebufferAndRenderPassLayouts(RenderPassCreateVersion rp_version, const CMD_BUFFER_STATE *pCB,
                                                        const VkRenderPassBeginInfo *pRenderPassBegin,
-                                                       const FRAMEBUFFER_STATE *framebuffer_state) {
+                                                       const FRAMEBUFFER_STATE *framebuffer_state) const {
     bool skip = false;
     auto const pRenderPassInfo = GetRenderPassState(pRenderPassBegin->renderPass)->createInfo.ptr();
     auto const &framebufferInfo = framebuffer_state->createInfo;
+    const VkImageView *attachments = framebufferInfo.pAttachments;
 
     auto render_pass = GetRenderPassState(pRenderPassBegin->renderPass)->renderPass;
     auto framebuffer = framebuffer_state->framebuffer;
@@ -469,116 +475,124 @@ bool CoreChecks::VerifyFramebufferAndRenderPassLayouts(RenderPassCreateVersion r
                         HandleToUint64(pCB->commandBuffer), kVUID_Core_DrawState_InvalidRenderpass,
                         "You cannot start a render pass using a framebuffer with a different number of attachments.");
     }
-    const auto *const_pCB = static_cast<const CMD_BUFFER_STATE *>(pCB);
-    for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) {
-        const VkImageView &image_view = framebufferInfo.pAttachments[i];
-        auto view_state = GetImageViewState(image_view);
 
-        if (!view_state) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-                            HandleToUint64(pRenderPassBegin->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
-                            "vkCmdBeginRenderPass(): %s pAttachments[%" PRIu32 "] = %s is not a valid VkImageView handle",
-                            report_data->FormatHandle(framebuffer_state->framebuffer).c_str(), i,
-                            report_data->FormatHandle(image_view).c_str());
-            continue;
-        }
+    const auto *attachmentInfo = lvl_find_in_chain<VkRenderPassAttachmentBeginInfoKHR>(pRenderPassBegin->pNext);
+    if (((framebufferInfo.flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) != 0) && attachmentInfo != nullptr) {
+        attachments = attachmentInfo->pAttachments;
+    }
 
-        const VkImage image = view_state->create_info.image;
-        const IMAGE_STATE *image_state = GetImageState(image);
+    if (attachments != nullptr) {
+        const auto *const_pCB = static_cast<const CMD_BUFFER_STATE *>(pCB);
+        for (uint32_t i = 0; i < pRenderPassInfo->attachmentCount; ++i) {
+            auto image_view = attachments[i];
+            auto view_state = GetImageViewState(image_view);
+
+            if (!view_state) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                HandleToUint64(pRenderPassBegin->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
+                                "vkCmdBeginRenderPass(): %s pAttachments[%" PRIu32 "] = %s is not a valid VkImageView handle",
+                                report_data->FormatHandle(framebuffer_state->framebuffer).c_str(), i,
+                                report_data->FormatHandle(image_view).c_str());
+                continue;
+            }
 
-        if (!image_state) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-                            HandleToUint64(pRenderPassBegin->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
-                            "vkCmdBeginRenderPass(): %s pAttachments[%" PRIu32 "] =  %s references non-extant %s.",
-                            report_data->FormatHandle(framebuffer_state->framebuffer).c_str(), i,
-                            report_data->FormatHandle(image_view).c_str(), report_data->FormatHandle(image).c_str());
-            continue;
-        }
-        auto attachment_initial_layout = pRenderPassInfo->pAttachments[i].initialLayout;
-        auto final_layout = pRenderPassInfo->pAttachments[i].finalLayout;
-
-        // Cast pCB to const because we don't want to create entries that don't exist here (in case the key changes to something
-        // in common with the non-const version.)
-        const ImageSubresourceLayoutMap *subresource_map =
-            (attachment_initial_layout != VK_IMAGE_LAYOUT_UNDEFINED) ? GetImageSubresourceLayoutMap(const_pCB, image) : nullptr;
-
-        if (subresource_map) {  // If no layout information for image yet, will be checked at QueueSubmit time
-            LayoutUseCheckAndMessage layout_check(subresource_map);
-            bool subres_skip = false;
-            auto subresource_cb = [this, i, attachment_initial_layout, &layout_check, &subres_skip](
-                                      const VkImageSubresource &subres, VkImageLayout layout, VkImageLayout initial_layout) {
-                if (!layout_check.Check(subres, attachment_initial_layout, layout, initial_layout)) {
-                    subres_skip |=
-                        log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                kVUID_Core_DrawState_InvalidRenderpass,
-                                "You cannot start a render pass using attachment %u where the render pass initial layout is %s "
-                                "and the %s layout of the attachment is %s. The layouts must match, or the render "
-                                "pass initial layout for the attachment must be VK_IMAGE_LAYOUT_UNDEFINED",
-                                i, string_VkImageLayout(attachment_initial_layout), layout_check.message,
-                                string_VkImageLayout(layout_check.layout));
-                }
-                return !subres_skip;  // quit checking subresources once we fail once
-            };
+            const VkImage image = view_state->create_info.image;
+            const IMAGE_STATE *image_state = GetImageState(image);
 
-            subresource_map->ForRange(view_state->normalized_subresource_range, subresource_cb);
-            skip |= subres_skip;
-        }
+            if (!image_state) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                HandleToUint64(pRenderPassBegin->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-parameter",
+                                "vkCmdBeginRenderPass(): %s pAttachments[%" PRIu32 "] =  %s references non-extant %s.",
+                                report_data->FormatHandle(framebuffer_state->framebuffer).c_str(), i,
+                                report_data->FormatHandle(image_view).c_str(), report_data->FormatHandle(image).c_str());
+                continue;
+            }
+            auto attachment_initial_layout = pRenderPassInfo->pAttachments[i].initialLayout;
+            auto final_layout = pRenderPassInfo->pAttachments[i].finalLayout;
 
-        ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_initial_layout, image, image_view, framebuffer,
-                                                             render_pass, i, "initial layout");
+            // Cast pCB to const because we don't want to create entries that don't exist here (in case the key changes to something
+            // in common with the non-const version.)
+            const ImageSubresourceLayoutMap *subresource_map =
+                (attachment_initial_layout != VK_IMAGE_LAYOUT_UNDEFINED) ? GetImageSubresourceLayoutMap(const_pCB, image) : nullptr;
 
-        ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, final_layout, image, image_view, framebuffer, render_pass,
-                                                             i, "final layout");
-    }
+            if (subresource_map) {  // If no layout information for image yet, will be checked at QueueSubmit time
+                LayoutUseCheckAndMessage layout_check(subresource_map);
+                bool subres_skip = false;
+                auto subresource_cb = [this, i, attachment_initial_layout, &layout_check, &subres_skip](
+                                          const VkImageSubresource &subres, VkImageLayout layout, VkImageLayout initial_layout) {
+                    if (!layout_check.Check(subres, attachment_initial_layout, layout, initial_layout)) {
+                        subres_skip |=
+                            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    kVUID_Core_DrawState_InvalidRenderpass,
+                                    "You cannot start a render pass using attachment %u where the render pass initial layout is %s "
+                                    "and the %s layout of the attachment is %s. The layouts must match, or the render "
+                                    "pass initial layout for the attachment must be VK_IMAGE_LAYOUT_UNDEFINED",
+                                    i, string_VkImageLayout(attachment_initial_layout), layout_check.message,
+                                    string_VkImageLayout(layout_check.layout));
+                    }
+                    return !subres_skip;  // quit checking subresources once we fail once
+                };
 
-    for (uint32_t j = 0; j < pRenderPassInfo->subpassCount; ++j) {
-        auto &subpass = pRenderPassInfo->pSubpasses[j];
-        for (uint32_t k = 0; k < pRenderPassInfo->pSubpasses[j].inputAttachmentCount; ++k) {
-            auto &attachment_ref = subpass.pInputAttachments[k];
-            if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
-                auto image_view = framebufferInfo.pAttachments[attachment_ref.attachment];
-                auto view_state = GetImageViewState(image_view);
+                subresource_map->ForRange(view_state->normalized_subresource_range, subresource_cb);
+                skip |= subres_skip;
+            }
 
-                if (view_state) {
-                    auto image = view_state->create_info.image;
-                    ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, image, image_view,
-                                                                         framebuffer, render_pass, attachment_ref.attachment,
-                                                                         "input attachment layout");
+            ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_initial_layout, image, image_view,
+                                                                 framebuffer, render_pass, i, "initial layout");
+
+            ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, final_layout, image, image_view, framebuffer,
+                                                                 render_pass, i, "final layout");
+        }
+
+        for (uint32_t j = 0; j < pRenderPassInfo->subpassCount; ++j) {
+            auto &subpass = pRenderPassInfo->pSubpasses[j];
+            for (uint32_t k = 0; k < pRenderPassInfo->pSubpasses[j].inputAttachmentCount; ++k) {
+                auto &attachment_ref = subpass.pInputAttachments[k];
+                if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
+                    auto image_view = attachments[attachment_ref.attachment];
+                    auto view_state = GetImageViewState(image_view);
+
+                    if (view_state) {
+                        auto image = view_state->create_info.image;
+                        ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, image, image_view,
+                                                                             framebuffer, render_pass, attachment_ref.attachment,
+                                                                             "input attachment layout");
+                    }
                 }
             }
-        }
 
-        for (uint32_t k = 0; k < pRenderPassInfo->pSubpasses[j].colorAttachmentCount; ++k) {
-            auto &attachment_ref = subpass.pColorAttachments[k];
-            if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
-                auto image_view = framebufferInfo.pAttachments[attachment_ref.attachment];
-                auto view_state = GetImageViewState(image_view);
+            for (uint32_t k = 0; k < pRenderPassInfo->pSubpasses[j].colorAttachmentCount; ++k) {
+                auto &attachment_ref = subpass.pColorAttachments[k];
+                if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
+                    auto image_view = attachments[attachment_ref.attachment];
+                    auto view_state = GetImageViewState(image_view);
 
-                if (view_state) {
-                    auto image = view_state->create_info.image;
-                    ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, image, image_view,
-                                                                         framebuffer, render_pass, attachment_ref.attachment,
-                                                                         "color attachment layout");
-                    if (subpass.pResolveAttachments) {
+                    if (view_state) {
+                        auto image = view_state->create_info.image;
                         ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, image, image_view,
                                                                              framebuffer, render_pass, attachment_ref.attachment,
-                                                                             "resolve attachment layout");
+                                                                             "color attachment layout");
+                        if (subpass.pResolveAttachments) {
+                            ValidateRenderPassLayoutAgainstFramebufferImageUsage(
+                                rp_version, attachment_ref.layout, image, image_view, framebuffer, render_pass,
+                                attachment_ref.attachment, "resolve attachment layout");
+                        }
                     }
                 }
             }
-        }
 
-        if (pRenderPassInfo->pSubpasses[j].pDepthStencilAttachment) {
-            auto &attachment_ref = *subpass.pDepthStencilAttachment;
-            if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
-                auto image_view = framebufferInfo.pAttachments[attachment_ref.attachment];
-                auto view_state = GetImageViewState(image_view);
+            if (pRenderPassInfo->pSubpasses[j].pDepthStencilAttachment) {
+                auto &attachment_ref = *subpass.pDepthStencilAttachment;
+                if (attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
+                    auto image_view = attachments[attachment_ref.attachment];
+                    auto view_state = GetImageViewState(image_view);
 
-                if (view_state) {
-                    auto image = view_state->create_info.image;
-                    ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, image, image_view,
-                                                                         framebuffer, render_pass, attachment_ref.attachment,
-                                                                         "input attachment layout");
+                    if (view_state) {
+                        auto image = view_state->create_info.image;
+                        ValidateRenderPassLayoutAgainstFramebufferImageUsage(rp_version, attachment_ref.layout, image, image_view,
+                                                                             framebuffer, render_pass, attachment_ref.attachment,
+                                                                             "input attachment layout");
+                    }
                 }
             }
         }
@@ -649,10 +663,11 @@ bool VerifyAspectsPresent(VkImageAspectFlags aspect_mask, VkFormat format) {
 }
 
 // Verify an ImageMemoryBarrier's old/new ImageLayouts are compatible with the Image's ImageUsageFlags.
-bool CoreChecks::ValidateBarrierLayoutToImageUsage(const VkImageMemoryBarrier *img_barrier, bool new_not_old,
-                                                   VkImageUsageFlags usage_flags, const char *func_name) {
+bool CoreChecks::ValidateBarrierLayoutToImageUsage(const VkImageMemoryBarrier &img_barrier, bool new_not_old,
+                                                   VkImageUsageFlags usage_flags, const char *func_name,
+                                                   const char *barrier_pname) {
     bool skip = false;
-    const VkImageLayout layout = (new_not_old) ? img_barrier->newLayout : img_barrier->oldLayout;
+    const VkImageLayout layout = (new_not_old) ? img_barrier.newLayout : img_barrier.oldLayout;
     const char *msg_code = kVUIDUndefined;  // sentinel value meaning "no error"
 
     switch (layout) {
@@ -698,123 +713,122 @@ bool CoreChecks::ValidateBarrierLayoutToImageUsage(const VkImageMemoryBarrier *i
 
     if (msg_code != kVUIDUndefined) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                        HandleToUint64(img_barrier->image), msg_code,
-                        "%s: Image barrier 0x%p %s Layout=%s is not compatible with %s usage flags 0x%" PRIx32 ".", func_name,
-                        static_cast<const void *>(img_barrier), ((new_not_old) ? "new" : "old"), string_VkImageLayout(layout),
-                        report_data->FormatHandle(img_barrier->image).c_str(), usage_flags);
+                        HandleToUint64(img_barrier.image), msg_code,
+                        "%s: Image barrier %s %s Layout=%s is not compatible with %s usage flags 0x%" PRIx32 ".", func_name,
+                        barrier_pname, ((new_not_old) ? "new" : "old"), string_VkImageLayout(layout),
+                        report_data->FormatHandle(img_barrier.image).c_str(), usage_flags);
     }
     return skip;
 }
 
-// Scoreboard for checking for duplicate and inconsistent barriers to images
-struct ImageBarrierScoreboardEntry {
-    uint32_t index;
-    // This is designed for temporary storage within the scope of the API call.  If retained storage of the barriers is
-    // required, copies should be made and smart or unique pointers used in some other stucture (or this one refactored)
-    const VkImageMemoryBarrier *barrier;
-};
-using ImageBarrierScoreboardSubresMap = std::unordered_map<VkImageSubresourceRange, ImageBarrierScoreboardEntry>;
-using ImageBarrierScoreboardImageMap = std::unordered_map<VkImage, ImageBarrierScoreboardSubresMap>;
-
 // Verify image barriers are compatible with the images they reference.
 bool CoreChecks::ValidateBarriersToImages(CMD_BUFFER_STATE const *cb_state, uint32_t imageMemoryBarrierCount,
                                           const VkImageMemoryBarrier *pImageMemoryBarriers, const char *func_name) {
     bool skip = false;
 
+    // Scoreboard for checking for duplicate and inconsistent barriers to images
+    struct ImageBarrierScoreboardEntry {
+        uint32_t index;
+        // This is designed for temporary storage within the scope of the API call.  If retained storage of the barriers is
+        // required, copies should be made and smart or unique pointers used in some other stucture (or this one refactored)
+        const VkImageMemoryBarrier *barrier;
+    };
+    using ImageBarrierScoreboardSubresMap = std::unordered_map<VkImageSubresourceRange, ImageBarrierScoreboardEntry>;
+    using ImageBarrierScoreboardImageMap = std::unordered_map<VkImage, ImageBarrierScoreboardSubresMap>;
+
     // Scoreboard for duplicate layout transition barriers within the list
     // Pointers retained in the scoreboard only have the lifetime of *this* call (i.e. within the scope of the API call)
     ImageBarrierScoreboardImageMap layout_transitions;
 
     for (uint32_t i = 0; i < imageMemoryBarrierCount; ++i) {
-        auto img_barrier = &pImageMemoryBarriers[i];
-        if (!img_barrier) continue;
+        const auto &img_barrier = pImageMemoryBarriers[i];
+        const std::string barrier_pname = "pImageMemoryBarrier[" + std::to_string(i) + "]";
 
         // Update the scoreboard of layout transitions and check for barriers affecting the same image and subresource
         // TODO: a higher precision could be gained by adapting the command_buffer image_layout_map logic looking for conflicts
         // at a per sub-resource level
-        if (img_barrier->oldLayout != img_barrier->newLayout) {
-            ImageBarrierScoreboardEntry new_entry{i, img_barrier};
-            auto image_it = layout_transitions.find(img_barrier->image);
+        if (img_barrier.oldLayout != img_barrier.newLayout) {
+            const ImageBarrierScoreboardEntry new_entry{i, &img_barrier};
+            const auto image_it = layout_transitions.find(img_barrier.image);
             if (image_it != layout_transitions.end()) {
                 auto &subres_map = image_it->second;
-                auto subres_it = subres_map.find(img_barrier->subresourceRange);
+                auto subres_it = subres_map.find(img_barrier.subresourceRange);
                 if (subres_it != subres_map.end()) {
                     auto &entry = subres_it->second;
-                    if ((entry.barrier->newLayout != img_barrier->oldLayout) &&
-                        (img_barrier->oldLayout != VK_IMAGE_LAYOUT_UNDEFINED)) {
-                        const VkImageSubresourceRange &range = img_barrier->subresourceRange;
+                    if ((entry.barrier->newLayout != img_barrier.oldLayout) &&
+                        (img_barrier.oldLayout != VK_IMAGE_LAYOUT_UNDEFINED)) {
+                        const VkImageSubresourceRange &range = img_barrier.subresourceRange;
                         skip = log_msg(
                             report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             HandleToUint64(cb_state->commandBuffer), "VUID-VkImageMemoryBarrier-oldLayout-01197",
-                            "%s: pImageMemoryBarrier[%u] conflicts with earlier entry pImageMemoryBarrier[%u]. %s"
+                            "%s: %s conflicts with earlier entry pImageMemoryBarrier[%u]. %s"
                             " subresourceRange: aspectMask=%u baseMipLevel=%u levelCount=%u, baseArrayLayer=%u, layerCount=%u; "
                             "conflicting barrier transitions image layout from %s when earlier barrier transitioned to layout %s.",
-                            func_name, i, entry.index, report_data->FormatHandle(img_barrier->image).c_str(), range.aspectMask,
-                            range.baseMipLevel, range.levelCount, range.baseArrayLayer, range.layerCount,
-                            string_VkImageLayout(img_barrier->oldLayout), string_VkImageLayout(entry.barrier->newLayout));
+                            func_name, barrier_pname.c_str(), entry.index, report_data->FormatHandle(img_barrier.image).c_str(),
+                            range.aspectMask, range.baseMipLevel, range.levelCount, range.baseArrayLayer, range.layerCount,
+                            string_VkImageLayout(img_barrier.oldLayout), string_VkImageLayout(entry.barrier->newLayout));
                     }
                     entry = new_entry;
                 } else {
-                    subres_map[img_barrier->subresourceRange] = new_entry;
+                    subres_map[img_barrier.subresourceRange] = new_entry;
                 }
             } else {
-                layout_transitions[img_barrier->image][img_barrier->subresourceRange] = new_entry;
+                layout_transitions[img_barrier.image][img_barrier.subresourceRange] = new_entry;
             }
         }
 
-        auto image_state = GetImageState(img_barrier->image);
+        auto image_state = GetImageState(img_barrier.image);
         if (image_state) {
             VkImageUsageFlags usage_flags = image_state->createInfo.usage;
-            skip |= ValidateBarrierLayoutToImageUsage(img_barrier, false, usage_flags, func_name);
-            skip |= ValidateBarrierLayoutToImageUsage(img_barrier, true, usage_flags, func_name);
+            skip |= ValidateBarrierLayoutToImageUsage(img_barrier, false, usage_flags, func_name, barrier_pname.c_str());
+            skip |= ValidateBarrierLayoutToImageUsage(img_barrier, true, usage_flags, func_name, barrier_pname.c_str());
 
             // Make sure layout is able to be transitioned, currently only presented shared presentable images are locked
             if (image_state->layout_locked) {
                 // TODO: Add unique id for error when available
                 skip |= log_msg(
                     report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                    HandleToUint64(img_barrier->image), 0,
+                    HandleToUint64(img_barrier.image), 0,
                     "Attempting to transition shared presentable %s"
                     " from layout %s to layout %s, but image has already been presented and cannot have its layout transitioned.",
-                    report_data->FormatHandle(img_barrier->image).c_str(), string_VkImageLayout(img_barrier->oldLayout),
-                    string_VkImageLayout(img_barrier->newLayout));
+                    report_data->FormatHandle(img_barrier.image).c_str(), string_VkImageLayout(img_barrier.oldLayout),
+                    string_VkImageLayout(img_barrier.newLayout));
             }
 
             VkImageCreateInfo *image_create_info = &image_state->createInfo;
             // For a Depth/Stencil image both aspects MUST be set
             if (FormatIsDepthAndStencil(image_create_info->format)) {
-                auto const aspect_mask = img_barrier->subresourceRange.aspectMask;
+                auto const aspect_mask = img_barrier.subresourceRange.aspectMask;
                 auto const ds_mask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
                 if ((aspect_mask & ds_mask) != (ds_mask)) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
-                                    HandleToUint64(img_barrier->image), "VUID-VkImageMemoryBarrier-image-01207",
-                                    "%s: Image barrier 0x%p references %s of format %s that must have the depth and stencil "
+                                    HandleToUint64(img_barrier.image), "VUID-VkImageMemoryBarrier-image-01207",
+                                    "%s: Image barrier %s references %s of format %s that must have the depth and stencil "
                                     "aspects set, but its aspectMask is 0x%" PRIx32 ".",
-                                    func_name, static_cast<const void *>(img_barrier),
-                                    report_data->FormatHandle(img_barrier->image).c_str(),
+                                    func_name, barrier_pname.c_str(), report_data->FormatHandle(img_barrier.image).c_str(),
                                     string_VkFormat(image_create_info->format), aspect_mask);
                 }
             }
 
-            const auto *subresource_map = GetImageSubresourceLayoutMap(cb_state, img_barrier->image);
-            if (img_barrier->oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
+            const auto *subresource_map = GetImageSubresourceLayoutMap(cb_state, img_barrier.image);
+            if (img_barrier.oldLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
                 // TODO: Set memory invalid which is in mem_tracker currently
                 // Not sure if this needs to be in the ForRange traversal, pulling it out as it is currently invariant with
                 // subresource.
             } else if (subresource_map) {
                 bool subres_skip = false;
                 LayoutUseCheckAndMessage layout_check(subresource_map);
-                VkImageSubresourceRange normalized_isr = NormalizeSubresourceRange(*image_state, img_barrier->subresourceRange);
+                VkImageSubresourceRange normalized_isr = NormalizeSubresourceRange(*image_state, img_barrier.subresourceRange);
                 auto subres_callback = [this, img_barrier, cb_state, &layout_check, &subres_skip](
                                            const VkImageSubresource &subres, VkImageLayout layout, VkImageLayout initial_layout) {
-                    if (!layout_check.Check(subres, img_barrier->oldLayout, layout, initial_layout)) {
+                    if (!layout_check.Check(subres, img_barrier.oldLayout, layout, initial_layout)) {
                         subres_skip =
                             log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                                     HandleToUint64(cb_state->commandBuffer), "VUID-VkImageMemoryBarrier-oldLayout-01197",
                                     "For %s you cannot transition the layout of aspect=%d level=%d layer=%d from %s when the "
                                     "%s layout is %s.",
-                                    report_data->FormatHandle(img_barrier->image).c_str(), subres.aspectMask, subres.mipLevel,
-                                    subres.arrayLayer, string_VkImageLayout(img_barrier->oldLayout), layout_check.message,
+                                    report_data->FormatHandle(img_barrier.image).c_str(), subres.aspectMask, subres.mipLevel,
+                                    subres.arrayLayer, string_VkImageLayout(img_barrier.oldLayout), layout_check.message,
                                     string_VkImageLayout(layout_check.layout));
                     }
                     return !subres_skip;
@@ -827,11 +841,11 @@ bool CoreChecks::ValidateBarriersToImages(CMD_BUFFER_STATE const *cb_state, uint
     return skip;
 }
 
-bool CoreChecks::IsReleaseOp(CMD_BUFFER_STATE *cb_state, VkImageMemoryBarrier const *barrier) {
-    if (!IsTransferOp(barrier)) return false;
+bool CoreChecks::IsReleaseOp(CMD_BUFFER_STATE *cb_state, const VkImageMemoryBarrier &barrier) const {
+    if (!IsTransferOp(&barrier)) return false;
 
     auto pool = GetCommandPoolState(cb_state->createInfo.commandPool);
-    return pool && TempIsReleaseOp<VkImageMemoryBarrier, true>(pool, barrier);
+    return pool && TempIsReleaseOp<VkImageMemoryBarrier, true>(pool, &barrier);
 }
 
 template <typename Barrier>
@@ -910,7 +924,7 @@ void CoreChecks::RecordBarriersQFOTransfers(CMD_BUFFER_STATE *cb_state, uint32_t
 
 template <typename BarrierRecord, typename Scoreboard>
 bool CoreChecks::ValidateAndUpdateQFOScoreboard(const debug_report_data *report_data, const CMD_BUFFER_STATE *cb_state,
-                                                const char *operation, const BarrierRecord &barrier, Scoreboard *scoreboard) {
+                                                const char *operation, const BarrierRecord &barrier, Scoreboard *scoreboard) const {
     // Record to the scoreboard or report that we have a duplication
     bool skip = false;
     auto inserted = scoreboard->insert(std::make_pair(barrier, cb_state));
@@ -928,7 +942,8 @@ bool CoreChecks::ValidateAndUpdateQFOScoreboard(const debug_report_data *report_
 }
 
 template <typename Barrier>
-bool CoreChecks::ValidateQueuedQFOTransferBarriers(CMD_BUFFER_STATE *cb_state, QFOTransferCBScoreboards<Barrier> *scoreboards) {
+bool CoreChecks::ValidateQueuedQFOTransferBarriers(const CMD_BUFFER_STATE *cb_state,
+                                                   QFOTransferCBScoreboards<Barrier> *scoreboards) const {
     using BarrierRecord = QFOTransferBarrier<Barrier>;
     using TypeTag = typename BarrierRecord::Tag;
     bool skip = false;
@@ -976,9 +991,9 @@ bool CoreChecks::ValidateQueuedQFOTransferBarriers(CMD_BUFFER_STATE *cb_state, Q
     return skip;
 }
 
-bool CoreChecks::ValidateQueuedQFOTransfers(CMD_BUFFER_STATE *cb_state,
+bool CoreChecks::ValidateQueuedQFOTransfers(const CMD_BUFFER_STATE *cb_state,
                                             QFOTransferCBScoreboards<VkImageMemoryBarrier> *qfo_image_scoreboards,
-                                            QFOTransferCBScoreboards<VkBufferMemoryBarrier> *qfo_buffer_scoreboards) {
+                                            QFOTransferCBScoreboards<VkBufferMemoryBarrier> *qfo_buffer_scoreboards) const {
     bool skip = false;
     skip |= ValidateQueuedQFOTransferBarriers<VkImageMemoryBarrier>(cb_state, qfo_image_scoreboards);
     skip |= ValidateQueuedQFOTransferBarriers<VkBufferMemoryBarrier>(cb_state, qfo_buffer_scoreboards);
@@ -1024,8 +1039,7 @@ void CoreChecks::EraseQFOImageRelaseBarriers(const VkImage &image) { EraseQFORel
 void CoreChecks::TransitionImageLayouts(CMD_BUFFER_STATE *cb_state, uint32_t memBarrierCount,
                                         const VkImageMemoryBarrier *pImgMemBarriers) {
     for (uint32_t i = 0; i < memBarrierCount; ++i) {
-        auto mem_barrier = &pImgMemBarriers[i];
-        if (!mem_barrier) continue;
+        const auto &mem_barrier = pImgMemBarriers[i];
 
         // For ownership transfers, the barrier is specified twice; as a release
         // operation on the yielding queue family, and as an acquire operation
@@ -1038,10 +1052,10 @@ void CoreChecks::TransitionImageLayouts(CMD_BUFFER_STATE *cb_state, uint32_t mem
             continue;
         }
 
-        auto *image_state = GetImageState(mem_barrier->image);
+        auto *image_state = GetImageState(mem_barrier.image);
         if (!image_state) continue;
 
-        VkImageSubresourceRange normalized_isr = NormalizeSubresourceRange(*image_state, mem_barrier->subresourceRange);
+        VkImageSubresourceRange normalized_isr = NormalizeSubresourceRange(*image_state, mem_barrier.subresourceRange);
         const auto &image_create_info = image_state->createInfo;
 
         // Special case for 3D images with VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR flag bit, where <extent.depth> and
@@ -1052,7 +1066,7 @@ void CoreChecks::TransitionImageLayouts(CMD_BUFFER_STATE *cb_state, uint32_t mem
             normalized_isr.layerCount = image_create_info.extent.depth;  // Treat each depth slice as a layer subresource
         }
 
-        SetImageLayout(cb_state, *image_state, normalized_isr, mem_barrier->newLayout, mem_barrier->oldLayout);
+        SetImageLayout(cb_state, *image_state, normalized_isr, mem_barrier.newLayout, mem_barrier.oldLayout);
     }
 }
 
@@ -1060,6 +1074,7 @@ bool CoreChecks::VerifyImageLayout(const CMD_BUFFER_STATE *cb_node, const IMAGE_
                                    const VkImageSubresourceRange &range, VkImageAspectFlags aspect_mask,
                                    VkImageLayout explicit_layout, VkImageLayout optimal_layout, const char *caller,
                                    const char *layout_invalid_msg_code, const char *layout_mismatch_msg_code, bool *error) const {
+    if (disabled.image_layout_validation) return false;
     assert(cb_node);
     assert(image_state);
     const auto image = image_state->image;
@@ -1284,10 +1299,10 @@ bool CoreChecks::ValidateCreateImageViewANDROID(const VkImageViewCreateInfo *cre
     return skip;
 }
 
-bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(const VkImage image) {
+bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(const VkImage image) const {
     bool skip = false;
 
-    IMAGE_STATE *image_state = GetImageState(image);
+    const IMAGE_STATE *image_state = GetImageState(image);
     if (image_state->imported_ahb && (0 == image_state->GetBoundMemory().size())) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, HandleToUint64(image),
                         "VUID-vkGetImageSubresourceLayout-image-01895",
@@ -1308,7 +1323,7 @@ void ValidationStateTracker::RecordCreateImageANDROID(const VkImageCreateInfo *c
 
 bool CoreChecks::ValidateCreateImageViewANDROID(const VkImageViewCreateInfo *create_info) { return false; }
 
-bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(const VkImage image) { return false; }
+bool CoreChecks::ValidateGetImageSubresourceLayoutANDROID(const VkImage image) const { return false; }
 
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
@@ -1360,6 +1375,36 @@ bool CoreChecks::PreCallValidateCreateImage(VkDevice device, const VkImageCreate
                         "maxFramebufferHeight");
     }
 
+    if (device_extensions.vk_ext_fragment_density_map) {
+        uint32_t ceiling_width =
+            (uint32_t)ceil((float)device_limits->maxFramebufferWidth /
+                           std::max((float)phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.width, 1.0f));
+        if ((pCreateInfo->usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) && (pCreateInfo->extent.width > ceiling_width)) {
+            skip |=
+                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        "VUID-VkImageCreateInfo-usage-02559",
+                        "vkCreateImage(): Image usage flags include a fragment density map bit and image width (%u) exceeds the "
+                        "ceiling of device "
+                        "maxFramebufferWidth (%u) / minFragmentDensityTexelSize.width (%u). The ceiling value: %u",
+                        pCreateInfo->extent.width, device_limits->maxFramebufferWidth,
+                        phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.width, ceiling_width);
+        }
+
+        uint32_t ceiling_height =
+            (uint32_t)ceil((float)device_limits->maxFramebufferHeight /
+                           std::max((float)phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.height, 1.0f));
+        if ((pCreateInfo->usage & VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT) && (pCreateInfo->extent.height > ceiling_height)) {
+            skip |=
+                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        "VUID-VkImageCreateInfo-usage-02560",
+                        "vkCreateImage(): Image usage flags include a fragment density map bit and image height (%u) exceeds the "
+                        "ceiling of device "
+                        "maxFramebufferHeight (%u) / minFragmentDensityTexelSize.height (%u). The ceiling value: %u",
+                        pCreateInfo->extent.height, device_limits->maxFramebufferHeight,
+                        phys_dev_ext_props.fragment_density_map_props.minFragmentDensityTexelSize.height, ceiling_height);
+        }
+    }
+
     VkImageFormatProperties format_limits = {};
     VkResult res = GetPDImageFormatProperties(pCreateInfo, &format_limits);
     if (res == VK_ERROR_FORMAT_NOT_SUPPORTED) {
@@ -1460,15 +1505,27 @@ bool CoreChecks::PreCallValidateCreateImage(VkDevice device, const VkImageCreate
 void ValidationStateTracker::PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
                                                        const VkAllocationCallbacks *pAllocator, VkImage *pImage, VkResult result) {
     if (VK_SUCCESS != result) return;
-    IMAGE_STATE *is_node = new IMAGE_STATE(*pImage, pCreateInfo);
+    std::unique_ptr<IMAGE_STATE> is_node(new IMAGE_STATE(*pImage, pCreateInfo));
     if (device_extensions.vk_android_external_memory_android_hardware_buffer) {
-        RecordCreateImageANDROID(pCreateInfo, is_node);
+        RecordCreateImageANDROID(pCreateInfo, is_node.get());
     }
     const auto swapchain_info = lvl_find_in_chain<VkImageSwapchainCreateInfoKHR>(pCreateInfo->pNext);
     if (swapchain_info) {
         is_node->create_from_swapchain = swapchain_info->swapchain;
     }
-    imageMap.insert(std::make_pair(*pImage, std::unique_ptr<IMAGE_STATE>(is_node)));
+
+    bool pre_fetch_memory_reqs = true;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    if (is_node->external_format_android) {
+        // Do not fetch requirements for external memory images
+        pre_fetch_memory_reqs = false;
+    }
+#endif
+    // Record the memory requirements in case they won't be queried
+    if (pre_fetch_memory_reqs) {
+        DispatchGetImageMemoryRequirements(device, *pImage, &is_node->requirements);
+    }
+    imageMap.insert(std::make_pair(*pImage, std::move(is_node)));
 }
 
 void CoreChecks::PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
@@ -1483,7 +1540,6 @@ void CoreChecks::PostCallRecordCreateImage(VkDevice device, const VkImageCreateI
     ImageSubresourcePair subpair{*pImage, false, VkImageSubresource()};
     imageSubresourceMap[*pImage].push_back(subpair);
     imageLayoutMap[subpair] = image_state;
-    imageLayoutMap[subpair] = image_state;
 }
 
 bool CoreChecks::PreCallValidateDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
@@ -2062,7 +2118,7 @@ bool CoreChecks::ValidateImageArrayLayerRange(const CMD_BUFFER_STATE *cb_node, c
 // Check valid usage Image Transfer Granularity requirements for elements of a VkBufferImageCopy structure
 bool CoreChecks::ValidateCopyBufferImageTransferGranularityRequirements(const CMD_BUFFER_STATE *cb_node, const IMAGE_STATE *img,
                                                                         const VkBufferImageCopy *region, const uint32_t i,
-                                                                        const char *function, const char *vuid) {
+                                                                        const char *function, const char *vuid) const {
     bool skip = false;
     VkExtent3D granularity = GetScaledItg(cb_node, img);
     skip |= CheckItgOffset(cb_node, &region->imageOffset, &granularity, i, function, "imageOffset", vuid);
@@ -2768,28 +2824,26 @@ bool CoreChecks::ValidateClearAttachmentExtent(VkCommandBuffer command_buffer, u
 bool CoreChecks::PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
                                                     const VkClearAttachment *pAttachments, uint32_t rectCount,
                                                     const VkClearRect *pRects) {
-    CMD_BUFFER_STATE *cb_node = GetCBState(commandBuffer);
-
     bool skip = false;
-    if (cb_node) {
-        skip |= ValidateCmdQueueFlags(cb_node, "vkCmdClearAttachments()", VK_QUEUE_GRAPHICS_BIT,
-                                      "VUID-vkCmdClearAttachments-commandBuffer-cmdpool");
-        skip |= ValidateCmd(cb_node, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()");
-        // Warn if this is issued prior to Draw Cmd and clearing the entire attachment
-        if (!cb_node->hasDrawCmd && (cb_node->activeRenderPassBeginInfo.renderArea.extent.width == pRects[0].rect.extent.width) &&
-            (cb_node->activeRenderPassBeginInfo.renderArea.extent.height == pRects[0].rect.extent.height)) {
-            // There are times where app needs to use ClearAttachments (generally when reusing a buffer inside of a render pass)
-            // This warning should be made more specific. It'd be best to avoid triggering this test if it's a use that must call
-            // CmdClearAttachments.
-            skip |=
-                log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+    const CMD_BUFFER_STATE *cb_node = GetCBState(commandBuffer);  // TODO: Should be const, and never modified during validation
+    if (!cb_node) return skip;
+
+    skip |= ValidateCmdQueueFlags(cb_node, "vkCmdClearAttachments()", VK_QUEUE_GRAPHICS_BIT,
+                                  "VUID-vkCmdClearAttachments-commandBuffer-cmdpool");
+    skip |= ValidateCmd(cb_node, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()");
+    // Warn if this is issued prior to Draw Cmd and clearing the entire attachment
+    if (!cb_node->hasDrawCmd && (cb_node->activeRenderPassBeginInfo.renderArea.extent.width == pRects[0].rect.extent.width) &&
+        (cb_node->activeRenderPassBeginInfo.renderArea.extent.height == pRects[0].rect.extent.height)) {
+        // There are times where app needs to use ClearAttachments (generally when reusing a buffer inside of a render pass)
+        // This warning should be made more specific. It'd be best to avoid triggering this test if it's a use that must call
+        // CmdClearAttachments.
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                         HandleToUint64(commandBuffer), kVUID_Core_DrawState_ClearCmdBeforeDraw,
                         "vkCmdClearAttachments() issued on %s prior to any Draw Cmds. It is recommended you "
                         "use RenderPass LOAD_OP_CLEAR on Attachments prior to any Draw.",
                         report_data->FormatHandle(commandBuffer).c_str());
-        }
-        skip |= OutsideRenderPass(cb_node, "vkCmdClearAttachments()", "VUID-vkCmdClearAttachments-renderpass");
     }
+    skip |= OutsideRenderPass(cb_node, "vkCmdClearAttachments()", "VUID-vkCmdClearAttachments-renderpass");
 
     // Validate that attachment is in reference list of active subpass
     if (cb_node->activeRenderPass) {
@@ -2798,7 +2852,6 @@ bool CoreChecks::PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffe
         const VkSubpassDescription2KHR *subpass_desc = &renderpass_create_info->pSubpasses[cb_node->activeSubpass];
         const auto *framebuffer = GetFramebufferState(cb_node->activeFramebuffer);
         const auto &render_area = cb_node->activeRenderPassBeginInfo.renderArea;
-        std::shared_ptr<std::vector<VkClearRect>> clear_rect_copy;
 
         for (uint32_t attachment_index = 0; attachment_index < attachmentCount; attachment_index++) {
             auto clear_desc = &pAttachments[attachment_index];
@@ -2866,19 +2919,42 @@ bool CoreChecks::PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffe
             if (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
                 skip |= ValidateClearAttachmentExtent(commandBuffer, attachment_index, framebuffer, fb_attachment, render_area,
                                                       rectCount, pRects);
-            } else {
-                // if a secondary level command buffer inherits the framebuffer from the primary command buffer
-                // (see VkCommandBufferInheritanceInfo), this validation must be deferred until queue submit time
+            }
+        }
+    }
+    return skip;
+}
+
+void CoreChecks::PreCallRecordCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                                  const VkClearAttachment *pAttachments, uint32_t rectCount,
+                                                  const VkClearRect *pRects) {
+    auto *cb_node = GetCBState(commandBuffer);
+    if (cb_node->activeRenderPass && (cb_node->createInfo.level == VK_COMMAND_BUFFER_LEVEL_SECONDARY)) {
+        const VkRenderPassCreateInfo2KHR *renderpass_create_info = cb_node->activeRenderPass->createInfo.ptr();
+        const VkSubpassDescription2KHR *subpass_desc = &renderpass_create_info->pSubpasses[cb_node->activeSubpass];
+        std::shared_ptr<std::vector<VkClearRect>> clear_rect_copy;
+        for (uint32_t attachment_index = 0; attachment_index < attachmentCount; attachment_index++) {
+            const auto clear_desc = &pAttachments[attachment_index];
+            uint32_t fb_attachment = VK_ATTACHMENT_UNUSED;
+            if ((clear_desc->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) &&
+                (clear_desc->colorAttachment < subpass_desc->colorAttachmentCount)) {
+                fb_attachment = subpass_desc->pColorAttachments[clear_desc->colorAttachment].attachment;
+            } else if ((clear_desc->aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) &&
+                       subpass_desc->pDepthStencilAttachment) {
+                fb_attachment = subpass_desc->pDepthStencilAttachment->attachment;
+            }
+            if (fb_attachment != VK_ATTACHMENT_UNUSED) {
                 if (!clear_rect_copy) {
                     // We need a copy of the clear rectangles that will persist until the last lambda executes
                     // but we want to create it as lazily as possible
                     clear_rect_copy.reset(new std::vector<VkClearRect>(pRects, pRects + rectCount));
                 }
-
+                // if a secondary level command buffer inherits the framebuffer from the primary command buffer
+                // (see VkCommandBufferInheritanceInfo), this validation must be deferred until queue submit time
                 auto val_fn = [this, commandBuffer, attachment_index, fb_attachment, rectCount, clear_rect_copy](
-                                  CMD_BUFFER_STATE *prim_cb, VkFramebuffer fb) {
+                                  const CMD_BUFFER_STATE *prim_cb, VkFramebuffer fb) {
                     assert(rectCount == clear_rect_copy->size());
-                    FRAMEBUFFER_STATE *framebuffer = GetFramebufferState(fb);
+                    const FRAMEBUFFER_STATE *framebuffer = GetFramebufferState(fb);
                     const auto &render_area = prim_cb->activeRenderPassBeginInfo.renderArea;
                     bool skip = false;
                     skip = ValidateClearAttachmentExtent(commandBuffer, attachment_index, framebuffer, fb_attachment, render_area,
@@ -2889,7 +2965,6 @@ bool CoreChecks::PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffe
             }
         }
     }
-    return skip;
 }
 
 bool CoreChecks::PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
@@ -3344,10 +3419,11 @@ void CoreChecks::PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImag
 }
 
 // This validates that the initial layout specified in the command buffer for the IMAGE is the same as the global IMAGE layout
-bool CoreChecks::ValidateCmdBufImageLayouts(
-    CMD_BUFFER_STATE *pCB, std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> const &globalImageLayoutMap,
-    std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> &overlayLayoutMap) {
+bool CoreChecks::ValidateCmdBufImageLayouts(const CMD_BUFFER_STATE *pCB, const ImageSubresPairLayoutMap &globalImageLayoutMap,
+                                            ImageSubresPairLayoutMap *overlayLayoutMap_arg) const {
+    if (disabled.image_layout_validation) return false;
     bool skip = false;
+    ImageSubresPairLayoutMap &overlayLayoutMap = *overlayLayoutMap_arg;
     // Iterate over the layout maps for each referenced image
     for (const auto &layout_map_entry : pCB->image_layout_map) {
         const auto image = layout_map_entry.first;
@@ -3432,7 +3508,7 @@ void CoreChecks::UpdateCmdBufImageLayouts(CMD_BUFFER_STATE *pCB) {
 // layout attachments don't have CLEAR as their loadOp.
 bool CoreChecks::ValidateLayoutVsAttachmentDescription(const debug_report_data *report_data, RenderPassCreateVersion rp_version,
                                                        const VkImageLayout first_layout, const uint32_t attachment,
-                                                       const VkAttachmentDescription2KHR &attachment_description) {
+                                                       const VkAttachmentDescription2KHR &attachment_description) const {
     bool skip = false;
     const char *vuid;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
@@ -3475,7 +3551,7 @@ bool CoreChecks::ValidateLayoutVsAttachmentDescription(const debug_report_data *
 }
 
 bool CoreChecks::ValidateLayouts(RenderPassCreateVersion rp_version, VkDevice device,
-                                 const VkRenderPassCreateInfo2KHR *pCreateInfo) {
+                                 const VkRenderPassCreateInfo2KHR *pCreateInfo) const {
     bool skip = false;
     const char *vuid;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
@@ -3532,7 +3608,7 @@ bool CoreChecks::ValidateLayouts(RenderPassCreateVersion rp_version, VkDevice de
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
                                     "Layout for input attachment reference %u in subpass %u is %s but must be "
                                     "DEPTH_STENCIL_READ_ONLY, SHADER_READ_ONLY_OPTIMAL, or GENERAL.",
-                                    j, i, string_VkImageLayout(subpass.pDepthStencilAttachment->layout));
+                                    j, i, string_VkImageLayout(subpass.pInputAttachments[j].layout));
                     break;
 
                 case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR:
@@ -3791,24 +3867,23 @@ bool CoreChecks::ValidateBufferViewRange(const BUFFER_STATE *buffer_state, const
                             range);
         }
         // Range must be a multiple of the element size of format
-        const size_t format_size = FormatElementSize(pCreateInfo->format);
-        if (range % format_size != 0) {
+        const uint32_t format_size = FormatElementSize(pCreateInfo->format);
+        if (SafeModulo(range, format_size) != 0) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
                             HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-range-00929",
                             "If VkBufferViewCreateInfo range (%" PRIuLEAST64
                             ") does not equal VK_WHOLE_SIZE, range must be a multiple of the element size of the format "
-                            "(" PRINTF_SIZE_T_SPECIFIER ").",
+                            "(%" PRIu32 ").",
                             range, format_size);
         }
         // Range divided by the element size of format must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements
-        if (range / format_size > device_limits->maxTexelBufferElements) {
-            skip |=
-                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
-                        HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-range-00930",
-                        "If VkBufferViewCreateInfo range (%" PRIuLEAST64
-                        ") does not equal VK_WHOLE_SIZE, range divided by the element size of the format (" PRINTF_SIZE_T_SPECIFIER
-                        ") must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements (%" PRIuLEAST32 ").",
-                        range, format_size, device_limits->maxTexelBufferElements);
+        if (SafeDivision(range, format_size) > device_limits->maxTexelBufferElements) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+                            HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-range-00930",
+                            "If VkBufferViewCreateInfo range (%" PRIuLEAST64
+                            ") does not equal VK_WHOLE_SIZE, range divided by the element size of the format (%" PRIu32
+                            ") must be less than or equal to VkPhysicalDeviceLimits::maxTexelBufferElements (%" PRIuLEAST32 ").",
+                            range, format_size, device_limits->maxTexelBufferElements);
         }
         // The sum of range and offset must be less than or equal to the size of buffer
         if (range + pCreateInfo->offset > buffer_state->createInfo.size) {
@@ -3912,7 +3987,12 @@ void ValidationStateTracker::PostCallRecordCreateBuffer(VkDevice device, const V
                                                         VkResult result) {
     if (result != VK_SUCCESS) return;
     // TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid
-    bufferMap.insert(std::make_pair(*pBuffer, std::unique_ptr<BUFFER_STATE>(new BUFFER_STATE(*pBuffer, pCreateInfo))));
+    std::unique_ptr<BUFFER_STATE> buffer_state(new BUFFER_STATE(*pBuffer, pCreateInfo));
+
+    // Get a set of requirements in the case the app does not
+    DispatchGetBufferMemoryRequirements(device, *pBuffer, &buffer_state->requirements);
+
+    bufferMap.insert(std::make_pair(*pBuffer, std::move(buffer_state)));
 }
 
 bool CoreChecks::PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
@@ -3939,6 +4019,68 @@ bool CoreChecks::PreCallValidateCreateBufferView(VkDevice device, const VkBuffer
         }
 
         const VkPhysicalDeviceLimits *device_limits = &phys_dev_props.limits;
+        // Buffer view offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment
+        if ((pCreateInfo->offset % device_limits->minTexelBufferOffsetAlignment) != 0 &&
+            !enabled_features.texel_buffer_alignment_features.texelBufferAlignment) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+                            HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-offset-02749",
+                            "VkBufferViewCreateInfo offset (%" PRIuLEAST64
+                            ") must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment (%" PRIuLEAST64 ").",
+                            pCreateInfo->offset, device_limits->minTexelBufferOffsetAlignment);
+        }
+
+        if (enabled_features.texel_buffer_alignment_features.texelBufferAlignment) {
+            VkDeviceSize elementSize = FormatElementSize(pCreateInfo->format);
+            if ((elementSize % 3) == 0) {
+                elementSize /= 3;
+            }
+            if (buffer_state->createInfo.usage & VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT) {
+                VkDeviceSize alignmentRequirement =
+                    phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetAlignmentBytes;
+                if (phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetSingleTexelAlignment) {
+                    alignmentRequirement = std::min(alignmentRequirement, elementSize);
+                }
+                if (SafeModulo(pCreateInfo->offset, alignmentRequirement) != 0) {
+                    skip |= log_msg(
+                        report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+                        HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-buffer-02750",
+                        "If buffer was created with usage containing VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, "
+                        "VkBufferViewCreateInfo offset (%" PRIuLEAST64
+                        ") must be a multiple of the lesser of "
+                        "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetAlignmentBytes (%" PRIuLEAST64
+                        ") or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::storageTexelBufferOffsetSingleTexelAlignment "
+                        "(%" PRId32
+                        ") is VK_TRUE, the size of a texel of the requested format. "
+                        "If the size of a texel is a multiple of three bytes, then the size of a "
+                        "single component of format is used instead",
+                        pCreateInfo->offset, phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetAlignmentBytes,
+                        phys_dev_ext_props.texel_buffer_alignment_props.storageTexelBufferOffsetSingleTexelAlignment);
+                }
+            }
+            if (buffer_state->createInfo.usage & VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT) {
+                VkDeviceSize alignmentRequirement =
+                    phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetAlignmentBytes;
+                if (phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetSingleTexelAlignment) {
+                    alignmentRequirement = std::min(alignmentRequirement, elementSize);
+                }
+                if (SafeModulo(pCreateInfo->offset, alignmentRequirement) != 0) {
+                    skip |= log_msg(
+                        report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+                        HandleToUint64(buffer_state->buffer), "VUID-VkBufferViewCreateInfo-buffer-02751",
+                        "If buffer was created with usage containing VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT, "
+                        "VkBufferViewCreateInfo offset (%" PRIuLEAST64
+                        ") must be a multiple of the lesser of "
+                        "VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetAlignmentBytes (%" PRIuLEAST64
+                        ") or, if VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::uniformTexelBufferOffsetSingleTexelAlignment "
+                        "(%" PRId32
+                        ") is VK_TRUE, the size of a texel of the requested format. "
+                        "If the size of a texel is a multiple of three bytes, then the size of a "
+                        "single component of format is used instead",
+                        pCreateInfo->offset, phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetAlignmentBytes,
+                        phys_dev_ext_props.texel_buffer_alignment_props.uniformTexelBufferOffsetSingleTexelAlignment);
+                }
+            }
+        }
 
         skip |= ValidateBufferViewRange(buffer_state, pCreateInfo, device_limits);
 
@@ -3956,7 +4098,7 @@ void ValidationStateTracker::PostCallRecordCreateBufferView(VkDevice device, con
 
 // For the given format verify that the aspect masks make sense
 bool CoreChecks::ValidateImageAspectMask(VkImage image, VkFormat format, VkImageAspectFlags aspect_mask, const char *func_name,
-                                         const char *vuid) {
+                                         const char *vuid) const {
     bool skip = false;
     VkDebugReportObjectTypeEXT objectType = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
     if (image != VK_NULL_HANDLE) {
@@ -4151,13 +4293,14 @@ bool CoreChecks::PreCallValidateCreateImageView(VkDevice device, const VkImageVi
     bool skip = false;
     IMAGE_STATE *image_state = GetImageState(pCreateInfo->image);
     if (image_state) {
-        skip |= ValidateImageUsageFlags(
-            image_state,
-            VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
-                VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
-                VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV,
-            false, kVUIDUndefined, "vkCreateImageView()",
-            "VK_IMAGE_USAGE_[SAMPLED|STORAGE|COLOR_ATTACHMENT|DEPTH_STENCIL_ATTACHMENT|INPUT_ATTACHMENT|SHADING_RATE_IMAGE]_BIT");
+        skip |=
+            ValidateImageUsageFlags(image_state,
+                                    VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
+                                        VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+                                        VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV | VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT,
+                                    false, kVUIDUndefined, "vkCreateImageView()",
+                                    "VK_IMAGE_USAGE_[SAMPLED|STORAGE|COLOR_ATTACHMENT|DEPTH_STENCIL_ATTACHMENT|INPUT_ATTACHMENT|"
+                                    "SHADING_RATE_IMAGE|FRAGMENT_DENSITY_MAP]_BIT");
         // If this isn't a sparse image, it needs to have memory backing it at CreateImageView time
         skip |= ValidateMemoryIsBoundToImage(image_state, "vkCreateImageView()", "VUID-VkImageViewCreateInfo-image-01020");
         // Checks imported from image layer
@@ -4364,9 +4507,9 @@ void ValidationStateTracker::PostCallRecordCreateImageView(VkDevice device, cons
 
 bool CoreChecks::PreCallValidateCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer,
                                               uint32_t regionCount, const VkBufferCopy *pRegions) {
-    auto cb_node = GetCBState(commandBuffer);
-    auto src_buffer_state = GetBufferState(srcBuffer);
-    auto dst_buffer_state = GetBufferState(dstBuffer);
+    const auto cb_node = GetCBState(commandBuffer);
+    const auto src_buffer_state = GetBufferState(srcBuffer);
+    const auto dst_buffer_state = GetBufferState(dstBuffer);
 
     bool skip = false;
     skip |= ValidateMemoryIsBoundToBuffer(src_buffer_state, "vkCmdCopyBuffer()", "VUID-vkCmdCopyBuffer-srcBuffer-00119");
@@ -4821,9 +4964,9 @@ static inline bool ValidateBufferBounds(const debug_report_data *report_data, IM
 
 bool CoreChecks::PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
                                                      VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy *pRegions) {
-    auto cb_node = GetCBState(commandBuffer);
-    auto src_image_state = GetImageState(srcImage);
-    auto dst_buffer_state = GetBufferState(dstBuffer);
+    const auto cb_node = GetCBState(commandBuffer);
+    const auto src_image_state = GetImageState(srcImage);
+    const auto dst_buffer_state = GetBufferState(dstBuffer);
 
     bool skip = ValidateBufferImageCopyData(regionCount, pRegions, src_image_state, "vkCmdCopyImageToBuffer");
 
@@ -4831,7 +4974,7 @@ bool CoreChecks::PreCallValidateCmdCopyImageToBuffer(VkCommandBuffer commandBuff
     skip |= ValidateCmd(cb_node, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()");
 
     // Command pool must support graphics, compute, or transfer operations
-    auto pPool = GetCommandPoolState(cb_node->createInfo.commandPool);
+    const auto pPool = GetCommandPoolState(cb_node->createInfo.commandPool);
 
     VkQueueFlags queue_flags = GetPhysicalDeviceState()->queue_family_properties[pPool->queueFamilyIndex].queueFlags;
 
@@ -4913,9 +5056,9 @@ void CoreChecks::PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer
 bool CoreChecks::PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
                                                      VkImageLayout dstImageLayout, uint32_t regionCount,
                                                      const VkBufferImageCopy *pRegions) {
-    auto cb_node = GetCBState(commandBuffer);
-    auto src_buffer_state = GetBufferState(srcBuffer);
-    auto dst_image_state = GetImageState(dstImage);
+    const auto cb_node = GetCBState(commandBuffer);
+    const auto src_buffer_state = GetBufferState(srcBuffer);
+    const auto dst_image_state = GetImageState(dstImage);
 
     bool skip = ValidateBufferImageCopyData(regionCount, pRegions, dst_image_state, "vkCmdCopyBufferToImage");
 
@@ -4923,7 +5066,7 @@ bool CoreChecks::PreCallValidateCmdCopyBufferToImage(VkCommandBuffer commandBuff
     skip |= ValidateCmd(cb_node, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()");
 
     // Command pool must support graphics, compute, or transfer operations
-    auto pPool = GetCommandPoolState(cb_node->createInfo.commandPool);
+    const auto pPool = GetCommandPoolState(cb_node->createInfo.commandPool);
     VkQueueFlags queue_flags = GetPhysicalDeviceState()->queue_family_properties[pPool->queueFamilyIndex].queueFlags;
     if (0 == (queue_flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT))) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -5012,7 +5155,7 @@ bool CoreChecks::PreCallValidateGetImageSubresourceLayout(VkDevice device, VkIma
                         "vkGetImageSubresourceLayout(): VkImageSubresource.aspectMask must have exactly 1 bit set.");
     }
 
-    IMAGE_STATE *image_entry = GetImageState(image);
+    const IMAGE_STATE *image_entry = GetImageState(image);
     if (!image_entry) {
         return skip;
     }
diff --git a/layers/buffer_validation.h b/layers/buffer_validation.h
index 4579123e0..a4cf548e8 100644
--- a/layers/buffer_validation.h
+++ b/layers/buffer_validation.h
@@ -39,10 +39,4 @@ uint32_t ResolveRemainingLevels(const VkImageSubresourceRange *range, uint32_t m
 uint32_t ResolveRemainingLayers(const VkImageSubresourceRange *range, uint32_t layers);
 VkImageSubresourceRange NormalizeSubresourceRange(const IMAGE_STATE &image_state, const VkImageSubresourceRange &range);
 
-bool FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> &imageLayoutMap, ImageSubresourcePair imgpair,
-                VkImageLayout &layout, const VkImageAspectFlags aspectMask);
-
-void SetLayout(std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> &imageLayoutMap, ImageSubresourcePair imgpair,
-               VkImageLayout layout);
-
 #endif  // CORE_VALIDATION_BUFFER_VALIDATION_H_
diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index 03303f140..51173f2c9 100644
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -44,6 +44,7 @@
 #include <cmath>
 #include <iostream>
 #include <list>
+#include <math.h>
 #include <map>
 #include <memory>
 #include <mutex>
@@ -115,7 +116,15 @@ static const VkDeviceMemory MEMTRACKER_SWAP_CHAIN_IMAGE_KEY = (VkDeviceMemory)(-
 // 2nd special memory handle used to flag object as unbound from memory
 static const VkDeviceMemory MEMORY_UNBOUND = VkDeviceMemory(~((uint64_t)(0)) - 1);
 
-// Get the global map of pending releases
+// Get the global maps of pending releases
+const GlobalQFOTransferBarrierMap<VkImageMemoryBarrier> &CoreChecks::GetGlobalQFOReleaseBarrierMap(
+    const QFOTransferBarrier<VkImageMemoryBarrier>::Tag &type_tag) const {
+    return qfo_release_image_barrier_map;
+}
+const GlobalQFOTransferBarrierMap<VkBufferMemoryBarrier> &CoreChecks::GetGlobalQFOReleaseBarrierMap(
+    const QFOTransferBarrier<VkBufferMemoryBarrier>::Tag &type_tag) const {
+    return qfo_release_buffer_barrier_map;
+}
 GlobalQFOTransferBarrierMap<VkImageMemoryBarrier> &CoreChecks::GetGlobalQFOReleaseBarrierMap(
     const QFOTransferBarrier<VkImageMemoryBarrier>::Tag &type_tag) {
     return qfo_release_image_barrier_map;
@@ -140,6 +149,13 @@ EVENT_STATE *ValidationStateTracker::GetEventState(VkEvent event) {
     return &it->second;
 }
 
+const QUEUE_STATE *ValidationStateTracker::GetQueueState(VkQueue queue) const {
+    auto it = queueMap.find(queue);
+    if (it == queueMap.cend()) {
+        return nullptr;
+    }
+    return &it->second;
+}
 QUEUE_STATE *ValidationStateTracker::GetQueueState(VkQueue queue) {
     auto it = queueMap.find(queue);
     if (it == queueMap.end()) {
@@ -148,6 +164,15 @@ QUEUE_STATE *ValidationStateTracker::GetQueueState(VkQueue queue) {
     return &it->second;
 }
 
+const PHYSICAL_DEVICE_STATE *ValidationStateTracker::GetPhysicalDeviceState(VkPhysicalDevice phys) const {
+    auto *phys_dev_map = ((physical_device_map.size() > 0) ? &physical_device_map : &instance_state->physical_device_map);
+    auto it = phys_dev_map->find(phys);
+    if (it == phys_dev_map->end()) {
+        return nullptr;
+    }
+    return &it->second;
+}
+
 PHYSICAL_DEVICE_STATE *ValidationStateTracker::GetPhysicalDeviceState(VkPhysicalDevice phys) {
     auto *phys_dev_map = ((physical_device_map.size() > 0) ? &physical_device_map : &instance_state->physical_device_map);
     auto it = phys_dev_map->find(phys);
@@ -161,19 +186,26 @@ PHYSICAL_DEVICE_STATE *ValidationStateTracker::GetPhysicalDeviceState() { return
 const PHYSICAL_DEVICE_STATE *ValidationStateTracker::GetPhysicalDeviceState() const { return physical_device_state; }
 
 // Return ptr to memory binding for given handle of specified type
-BINDABLE *ValidationStateTracker::GetObjectMemBinding(const VulkanTypedHandle &typed_handle) {
+template <typename State, typename Result>
+static Result GetObjectMemBindingImpl(State state, const VulkanTypedHandle &typed_handle) {
     switch (typed_handle.type) {
         case kVulkanObjectTypeImage:
-            return GetImageState(VkImage(typed_handle.handle));
+            return state->GetImageState(typed_handle.Cast<VkImage>());
         case kVulkanObjectTypeBuffer:
-            return GetBufferState(VkBuffer(typed_handle.handle));
+            return state->GetBufferState(typed_handle.Cast<VkBuffer>());
         case kVulkanObjectTypeAccelerationStructureNV:
-            return GetAccelerationStructureState(VkAccelerationStructureNV(typed_handle.handle));
+            return state->GetAccelerationStructureState(typed_handle.Cast<VkAccelerationStructureNV>());
         default:
             break;
     }
     return nullptr;
 }
+const BINDABLE *ValidationStateTracker::GetObjectMemBinding(const VulkanTypedHandle &typed_handle) const {
+    return GetObjectMemBindingImpl<const ValidationStateTracker *, const BINDABLE *>(this, typed_handle);
+}
+BINDABLE *ValidationStateTracker::GetObjectMemBinding(const VulkanTypedHandle &typed_handle) {
+    return GetObjectMemBindingImpl<ValidationStateTracker *, BINDABLE *>(this, typed_handle);
+}
 
 ImageSubresourceLayoutMap::InitialLayoutState::InitialLayoutState(const CMD_BUFFER_STATE &cb_state,
                                                                   const IMAGE_VIEW_STATE *view_state)
@@ -277,7 +309,10 @@ void ValidationStateTracker::AddMemObjInfo(void *object, const VkDeviceMemory me
 }
 
 // Create binding link between given sampler and command buffer node
-void CoreChecks::AddCommandBufferBindingSampler(CMD_BUFFER_STATE *cb_node, SAMPLER_STATE *sampler_state) {
+void ValidationStateTracker::AddCommandBufferBindingSampler(CMD_BUFFER_STATE *cb_node, SAMPLER_STATE *sampler_state) {
+    if (disabled.command_buffer_state) {
+        return;
+    }
     auto inserted = cb_node->object_bindings.emplace(sampler_state->sampler, kVulkanObjectTypeSampler);
     if (inserted.second) {
         // Only need to complete the cross-reference if this is a new item
@@ -287,6 +322,9 @@ void CoreChecks::AddCommandBufferBindingSampler(CMD_BUFFER_STATE *cb_node, SAMPL
 
 // Create binding link between given image node and command buffer node
 void ValidationStateTracker::AddCommandBufferBindingImage(CMD_BUFFER_STATE *cb_node, IMAGE_STATE *image_state) {
+    if (disabled.command_buffer_state) {
+        return;
+    }
     // Skip validation if this image was created through WSI
     if (image_state->binding.mem != MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) {
         // First update cb binding for image
@@ -312,6 +350,9 @@ void ValidationStateTracker::AddCommandBufferBindingImage(CMD_BUFFER_STATE *cb_n
 
 // Create binding link between given image view node and its image with command buffer node
 void ValidationStateTracker::AddCommandBufferBindingImageView(CMD_BUFFER_STATE *cb_node, IMAGE_VIEW_STATE *view_state) {
+    if (disabled.command_buffer_state) {
+        return;
+    }
     // First add bindings for imageView
     auto inserted = cb_node->object_bindings.emplace(view_state->image_view, kVulkanObjectTypeImageView);
     if (inserted.second) {
@@ -327,6 +368,9 @@ void ValidationStateTracker::AddCommandBufferBindingImageView(CMD_BUFFER_STATE *
 
 // Create binding link between given buffer node and command buffer node
 void ValidationStateTracker::AddCommandBufferBindingBuffer(CMD_BUFFER_STATE *cb_node, BUFFER_STATE *buffer_state) {
+    if (disabled.command_buffer_state) {
+        return;
+    }
     // First update cb binding for buffer
     auto buffer_inserted = cb_node->object_bindings.emplace(buffer_state->buffer, kVulkanObjectTypeBuffer);
     if (buffer_inserted.second) {
@@ -349,6 +393,9 @@ void ValidationStateTracker::AddCommandBufferBindingBuffer(CMD_BUFFER_STATE *cb_
 
 // Create binding link between given buffer view node and its buffer with command buffer node
 void ValidationStateTracker::AddCommandBufferBindingBufferView(CMD_BUFFER_STATE *cb_node, BUFFER_VIEW_STATE *view_state) {
+    if (disabled.command_buffer_state) {
+        return;
+    }
     // First add bindings for bufferView
     auto inserted = cb_node->object_bindings.emplace(view_state->buffer_view, kVulkanObjectTypeBufferView);
     if (inserted.second) {
@@ -363,7 +410,11 @@ void ValidationStateTracker::AddCommandBufferBindingBufferView(CMD_BUFFER_STATE
 }
 
 // Create binding link between given acceleration structure and command buffer node
-void CoreChecks::AddCommandBufferBindingAccelerationStructure(CMD_BUFFER_STATE *cb_node, ACCELERATION_STRUCTURE_STATE *as_state) {
+void ValidationStateTracker::AddCommandBufferBindingAccelerationStructure(CMD_BUFFER_STATE *cb_node,
+                                                                          ACCELERATION_STRUCTURE_STATE *as_state) {
+    if (disabled.command_buffer_state) {
+        return;
+    }
     auto as_inserted = cb_node->object_bindings.emplace(as_state->acceleration_structure, kVulkanObjectTypeAccelerationStructureNV);
     if (as_inserted.second) {
         // Only need to complete the cross-reference if this is a new item
@@ -482,8 +533,8 @@ bool CoreChecks::ValidateMemoryIsBoundToAccelerationStructure(const ACCELERATION
 
 // SetMemBinding is used to establish immutable, non-sparse binding between a single image/buffer object and memory object.
 // Corresponding valid usage checks are in ValidateSetMemBinding().
-void CoreChecks::SetMemBinding(VkDeviceMemory mem, BINDABLE *mem_binding, VkDeviceSize memory_offset,
-                               const VulkanTypedHandle &typed_handle) {
+void ValidationStateTracker::SetMemBinding(VkDeviceMemory mem, BINDABLE *mem_binding, VkDeviceSize memory_offset,
+                                           const VulkanTypedHandle &typed_handle) {
     assert(mem_binding);
     mem_binding->binding.mem = mem;
     mem_binding->UpdateBoundMemorySet();  // force recreation of cached set
@@ -516,11 +567,11 @@ void CoreChecks::SetMemBinding(VkDeviceMemory mem, BINDABLE *mem_binding, VkDevi
 //  Otherwise, add reference from objectInfo to memoryInfo
 //  Add reference off of objInfo
 // TODO: We may need to refactor or pass in multiple valid usage statements to handle multiple valid usage conditions.
-bool CoreChecks::ValidateSetMemBinding(VkDeviceMemory mem, const VulkanTypedHandle &typed_handle, const char *apiName) {
+bool CoreChecks::ValidateSetMemBinding(VkDeviceMemory mem, const VulkanTypedHandle &typed_handle, const char *apiName) const {
     bool skip = false;
     // It's an error to bind an object to NULL memory
     if (mem != VK_NULL_HANDLE) {
-        BINDABLE *mem_binding = GetObjectMemBinding(typed_handle);
+        const BINDABLE *mem_binding = ValidationStateTracker::GetObjectMemBinding(typed_handle);
         assert(mem_binding);
         if (mem_binding->sparse) {
             const char *error_code = "VUID-vkBindImageMemory-image-01045";
@@ -538,9 +589,9 @@ bool CoreChecks::ValidateSetMemBinding(VkDeviceMemory mem, const VulkanTypedHand
                             apiName, report_data->FormatHandle(mem).c_str(), report_data->FormatHandle(typed_handle).c_str(),
                             handle_type);
         }
-        DEVICE_MEMORY_STATE *mem_info = GetDevMemState(mem);
+        const DEVICE_MEMORY_STATE *mem_info = ValidationStateTracker::GetDevMemState(mem);
         if (mem_info) {
-            DEVICE_MEMORY_STATE *prev_binding = GetDevMemState(mem_binding->binding.mem);
+            const DEVICE_MEMORY_STATE *prev_binding = ValidationStateTracker::GetDevMemState(mem_binding->binding.mem);
             if (prev_binding) {
                 const char *error_code = "VUID-vkBindImageMemory-image-01044";
                 if (typed_handle.type == kVulkanObjectTypeBuffer) {
@@ -595,7 +646,7 @@ bool CoreChecks::SetSparseMemBinding(MEM_BINDING binding, const VulkanTypedHandl
 }
 
 bool CoreChecks::ValidateDeviceQueueFamily(uint32_t queue_family, const char *cmd_name, const char *parameter_name,
-                                           const char *error_code, bool optional = false) {
+                                           const char *error_code, bool optional = false) const {
     bool skip = false;
     if (!optional && queue_family == VK_QUEUE_FAMILY_IGNORED) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
@@ -615,7 +666,7 @@ bool CoreChecks::ValidateDeviceQueueFamily(uint32_t queue_family, const char *cm
 
 bool CoreChecks::ValidateQueueFamilies(uint32_t queue_family_count, const uint32_t *queue_families, const char *cmd_name,
                                        const char *array_parameter_name, const char *unique_error_code,
-                                       const char *valid_error_code, bool optional = false) {
+                                       const char *valid_error_code, bool optional = false) const {
     bool skip = false;
     if (queue_families) {
         std::unordered_set<uint32_t> set;
@@ -636,8 +687,8 @@ bool CoreChecks::ValidateQueueFamilies(uint32_t queue_family_count, const uint32
 }
 
 // Check object status for selected flag state
-bool CoreChecks::ValidateStatus(CMD_BUFFER_STATE *pNode, CBStatusFlags status_mask, VkFlags msg_flags, const char *fail_msg,
-                                const char *msg_code) {
+bool CoreChecks::ValidateStatus(const CMD_BUFFER_STATE *pNode, CBStatusFlags status_mask, VkFlags msg_flags, const char *fail_msg,
+                                const char *msg_code) const {
     if (!(pNode->status & status_mask)) {
         return log_msg(report_data, msg_flags, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, HandleToUint64(pNode->commandBuffer),
                        msg_code, "%s: %s..", report_data->FormatHandle(pNode->commandBuffer).c_str(), fail_msg);
@@ -645,6 +696,14 @@ bool CoreChecks::ValidateStatus(CMD_BUFFER_STATE *pNode, CBStatusFlags status_ma
     return false;
 }
 
+const RENDER_PASS_STATE *ValidationStateTracker::GetRenderPassState(VkRenderPass renderpass) const {
+    auto it = renderPassMap.find(renderpass);
+    if (it == renderPassMap.end()) {
+        return nullptr;
+    }
+    return it->second.get();
+}
+
 RENDER_PASS_STATE *ValidationStateTracker::GetRenderPassState(VkRenderPass renderpass) {
     auto it = renderPassMap.find(renderpass);
     if (it == renderPassMap.end()) {
@@ -681,7 +740,8 @@ static bool IsDynamic(const PIPELINE_STATE *pPipeline, const VkDynamicState stat
 }
 
 // Validate state stored as flags at time of draw call
-bool CoreChecks::ValidateDrawStateFlags(CMD_BUFFER_STATE *pCB, const PIPELINE_STATE *pPipe, bool indexed, const char *msg_code) {
+bool CoreChecks::ValidateDrawStateFlags(const CMD_BUFFER_STATE *pCB, const PIPELINE_STATE *pPipe, bool indexed,
+                                        const char *msg_code) const {
     bool result = false;
     if (pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ||
         pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP) {
@@ -715,6 +775,15 @@ bool CoreChecks::ValidateDrawStateFlags(CMD_BUFFER_STATE *pCB, const PIPELINE_ST
         result |= ValidateStatus(pCB, CBSTATUS_INDEX_BUFFER_BOUND, VK_DEBUG_REPORT_ERROR_BIT_EXT,
                                  "Index buffer object not bound to this command buffer when Indexed Draw attempted", msg_code);
     }
+    if (pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_LIST ||
+        pPipe->topology_at_rasterizer == VK_PRIMITIVE_TOPOLOGY_LINE_STRIP) {
+        const auto *line_state =
+            lvl_find_in_chain<VkPipelineRasterizationLineStateCreateInfoEXT>(pPipe->graphicsPipelineCI.pRasterizationState->pNext);
+        if (line_state && line_state->stippledLineEnable) {
+            result |= ValidateStatus(pCB, CBSTATUS_LINE_STIPPLE_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                     "Dynamic line stipple state not set for this command buffer", msg_code);
+        }
+    }
 
     return result;
 }
@@ -871,16 +940,17 @@ static void ListBits(std::ostream &s, uint32_t bits) {
 }
 
 // Validate draw-time state related to the PSO
-bool CoreChecks::ValidatePipelineDrawtimeState(LAST_BOUND_STATE const &state, const CMD_BUFFER_STATE *pCB, CMD_TYPE cmd_type,
-                                               PIPELINE_STATE const *pPipeline, const char *caller) {
+bool CoreChecks::ValidatePipelineDrawtimeState(const LAST_BOUND_STATE &state, const CMD_BUFFER_STATE *pCB, CMD_TYPE cmd_type,
+                                               const PIPELINE_STATE *pPipeline, const char *caller) const {
     bool skip = false;
+    const auto &current_vtx_bfr_binding_info = pCB->current_vertex_buffer_binding_info.vertex_buffer_bindings;
 
     // Verify vertex binding
     if (pPipeline->vertex_binding_descriptions_.size() > 0) {
         for (size_t i = 0; i < pPipeline->vertex_binding_descriptions_.size(); i++) {
             const auto vertex_binding = pPipeline->vertex_binding_descriptions_[i].binding;
-            if ((pCB->current_draw_data.vertex_buffer_bindings.size() < (vertex_binding + 1)) ||
-                (pCB->current_draw_data.vertex_buffer_bindings[vertex_binding].buffer == VK_NULL_HANDLE)) {
+            if ((current_vtx_bfr_binding_info.size() < (vertex_binding + 1)) ||
+                (current_vtx_bfr_binding_info[vertex_binding].buffer == VK_NULL_HANDLE)) {
                 skip |=
                     log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             HandleToUint64(pCB->commandBuffer), kVUID_Core_DrawState_VtxIndexOutOfBounds,
@@ -900,35 +970,35 @@ bool CoreChecks::ValidatePipelineDrawtimeState(LAST_BOUND_STATE const &state, co
 
             const auto &vertex_binding_map_it = pPipeline->vertex_binding_to_index_map_.find(vertex_binding);
             if ((vertex_binding_map_it != pPipeline->vertex_binding_to_index_map_.cend()) &&
-                (vertex_binding < pCB->current_draw_data.vertex_buffer_bindings.size()) &&
-                (pCB->current_draw_data.vertex_buffer_bindings[vertex_binding].buffer != VK_NULL_HANDLE)) {
+                (vertex_binding < current_vtx_bfr_binding_info.size()) &&
+                (current_vtx_bfr_binding_info[vertex_binding].buffer != VK_NULL_HANDLE)) {
                 const auto vertex_buffer_stride = pPipeline->vertex_binding_descriptions_[vertex_binding_map_it->second].stride;
-                const auto vertex_buffer_offset = pCB->current_draw_data.vertex_buffer_bindings[vertex_binding].offset;
-                const auto buffer_state = GetBufferState(pCB->current_draw_data.vertex_buffer_bindings[vertex_binding].buffer);
+                const auto vertex_buffer_offset = current_vtx_bfr_binding_info[vertex_binding].offset;
+                const auto buffer_state = GetBufferState(current_vtx_bfr_binding_info[vertex_binding].buffer);
 
                 // Use only memory binding offset as base memory should be properly aligned by the driver
                 const auto buffer_binding_address = buffer_state->binding.offset + vertex_buffer_offset;
                 // Use 1 as vertex/instance index to use buffer stride as well
                 const auto attrib_address = buffer_binding_address + vertex_buffer_stride + attribute_offset;
 
-                uint32_t vtx_attrib_req_alignment = FormatElementSize(attribute_format);
+                VkDeviceSize vtx_attrib_req_alignment = FormatElementSize(attribute_format);
                 if (FormatElementIsTexel(attribute_format)) {
-                    vtx_attrib_req_alignment /= FormatChannelCount(attribute_format);
+                    vtx_attrib_req_alignment = SafeDivision(vtx_attrib_req_alignment, FormatChannelCount(attribute_format));
                 }
 
                 if (SafeModulo(attrib_address, vtx_attrib_req_alignment) != 0) {
-                    skip |= log_msg(
-                        report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
-                        HandleToUint64(pCB->current_draw_data.vertex_buffer_bindings[vertex_binding].buffer),
-                        kVUID_Core_DrawState_InvalidVtxAttributeAlignment,
-                        "Invalid attribAddress alignment for vertex attribute " PRINTF_SIZE_T_SPECIFIER " from %s and vertex %s.",
-                        i, report_data->FormatHandle(state.pipeline_state->pipeline).c_str(),
-                        report_data->FormatHandle(pCB->current_draw_data.vertex_buffer_bindings[vertex_binding].buffer).c_str());
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
+                                    HandleToUint64(current_vtx_bfr_binding_info[vertex_binding].buffer),
+                                    kVUID_Core_DrawState_InvalidVtxAttributeAlignment,
+                                    "Invalid attribAddress alignment for vertex attribute " PRINTF_SIZE_T_SPECIFIER
+                                    " from %s and vertex %s.",
+                                    i, report_data->FormatHandle(state.pipeline_state->pipeline).c_str(),
+                                    report_data->FormatHandle(current_vtx_bfr_binding_info[vertex_binding].buffer).c_str());
                 }
             }
         }
     } else {
-        if ((!pCB->current_draw_data.vertex_buffer_bindings.empty()) && (!pCB->vertex_buffer_used)) {
+        if ((!current_vtx_bfr_binding_info.empty()) && (!pCB->vertex_buffer_used)) {
             skip |=
                 log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                         HandleToUint64(pCB->commandBuffer), kVUID_Core_DrawState_VtxIndexOutOfBounds,
@@ -1091,12 +1161,15 @@ static bool VerifySetLayoutCompatibility(const cvdescriptorset::DescriptorSet *d
 }
 
 // Validate overall state at the time of a draw call
-bool CoreChecks::ValidateCmdBufDrawState(CMD_BUFFER_STATE *cb_node, CMD_TYPE cmd_type, const bool indexed,
+bool CoreChecks::ValidateCmdBufDrawState(const CMD_BUFFER_STATE *cb_node, CMD_TYPE cmd_type, const bool indexed,
                                          const VkPipelineBindPoint bind_point, const char *function, const char *pipe_err_code,
-                                         const char *state_err_code) {
-    bool result = false;
-    auto const &state = cb_node->lastBound[bind_point];
-    PIPELINE_STATE *pPipe = state.pipeline_state;
+                                         const char *state_err_code) const {
+    const auto last_bound_it = cb_node->lastBound.find(bind_point);
+    const PIPELINE_STATE *pPipe = nullptr;
+    if (last_bound_it != cb_node->lastBound.cend()) {
+        pPipe = last_bound_it->second.pipeline_state;
+    }
+
     if (nullptr == pPipe) {
         return log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                        HandleToUint64(cb_node->commandBuffer), pipe_err_code,
@@ -1104,6 +1177,9 @@ bool CoreChecks::ValidateCmdBufDrawState(CMD_BUFFER_STATE *cb_node, CMD_TYPE cmd
                        bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS ? "Graphics" : "Compute");
     }
 
+    bool result = false;
+    auto const &state = last_bound_it->second;
+
     // First check flag states
     if (VK_PIPELINE_BIND_POINT_GRAPHICS == bind_point) result = ValidateDrawStateFlags(cb_node, pPipe, indexed, state_err_code);
 
@@ -1114,14 +1190,15 @@ bool CoreChecks::ValidateCmdBufDrawState(CMD_BUFFER_STATE *cb_node, CMD_TYPE cmd
     for (const auto &set_binding_pair : pPipe->active_slots) {
         uint32_t setIndex = set_binding_pair.first;
         // If valid set is not bound throw an error
-        if ((state.boundDescriptorSets.size() <= setIndex) || (!state.boundDescriptorSets[setIndex])) {
+        if ((state.per_set.size() <= setIndex) || (!state.per_set[setIndex].bound_descriptor_set)) {
             result |=
                 log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                         HandleToUint64(cb_node->commandBuffer), kVUID_Core_DrawState_DescriptorSetNotBound,
                         "%s uses set #%u but that set is not bound.", report_data->FormatHandle(pPipe->pipeline).c_str(), setIndex);
-        } else if (!VerifySetLayoutCompatibility(state.boundDescriptorSets[setIndex], &pipeline_layout, setIndex, errorString)) {
+        } else if (!VerifySetLayoutCompatibility(state.per_set[setIndex].bound_descriptor_set, &pipeline_layout, setIndex,
+                                                 errorString)) {
             // Set is bound but not compatible w/ overlapping pipeline_layout from PSO
-            VkDescriptorSet setHandle = state.boundDescriptorSets[setIndex]->GetSet();
+            VkDescriptorSet setHandle = state.per_set[setIndex].bound_descriptor_set->GetSet();
             result |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
                               HandleToUint64(setHandle), kVUID_Core_DrawState_PipelineLayoutsIncompatible,
                               "%s bound as set #%u is not compatible with overlapping %s due to: %s",
@@ -1129,7 +1206,7 @@ bool CoreChecks::ValidateCmdBufDrawState(CMD_BUFFER_STATE *cb_node, CMD_TYPE cmd
                               report_data->FormatHandle(pipeline_layout.layout).c_str(), errorString.c_str());
         } else {  // Valid set is bound and layout compatible, validate that it's updated
             // Pull the set node
-            cvdescriptorset::DescriptorSet *descriptor_set = state.boundDescriptorSets[setIndex];
+            const cvdescriptorset::DescriptorSet *descriptor_set = state.per_set[setIndex].bound_descriptor_set;
             // Validate the draw-time state for this descriptor set
             std::string err_str;
             if (!descriptor_set->IsPushDescriptor()) {
@@ -1137,17 +1214,38 @@ bool CoreChecks::ValidateCmdBufDrawState(CMD_BUFFER_STATE *cb_node, CMD_TYPE cmd
                 // binding validation. Take the requested binding set and prefilter it to eliminate redundant validation checks.
                 // Here, the currently bound pipeline determines whether an image validation check is redundant...
                 // for images are the "req" portion of the binding_req is indirectly (but tightly) coupled to the pipeline.
-                const cvdescriptorset::PrefilterBindRequestMap reduced_map(*descriptor_set, set_binding_pair.second, cb_node,
-                                                                           pPipe);
-                const auto &binding_req_map = reduced_map.Map();
-
-                if (!ValidateDrawState(descriptor_set, binding_req_map, state.dynamicOffsets[setIndex], cb_node, function,
-                                       &err_str)) {
-                    auto set = descriptor_set->GetSet();
-                    result |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
-                                      HandleToUint64(set), kVUID_Core_DrawState_DescriptorSetNotUpdated,
-                                      "%s bound as set #%u encountered the following validation error at %s time: %s",
-                                      report_data->FormatHandle(set).c_str(), setIndex, function, err_str.c_str());
+                cvdescriptorset::PrefilterBindRequestMap reduced_map(*descriptor_set, set_binding_pair.second);
+                const auto &binding_req_map = reduced_map.FilteredMap(*cb_node, *pPipe);
+
+                // We can skip validating the descriptor set if "nothing" has changed since the last validation.
+                // Same set, no image layout changes, and same "pipeline state" (binding_req_map). If there are
+                // any dynamic descriptors, always revalidate rather than caching the values. We currently only
+                // apply this optimization if IsManyDescriptors is true, to avoid the overhead of copying the
+                // binding_req_map which could potentially be expensive.
+                bool need_validate =
+                    !reduced_map.IsManyDescriptors() ||
+                    // Revalidate each time if the set has dynamic offsets
+                    state.per_set[setIndex].dynamicOffsets.size() > 0 ||
+                    // Revalidate if descriptor set (or contents) has changed
+                    state.per_set[setIndex].validated_set != descriptor_set ||
+                    state.per_set[setIndex].validated_set_change_count != descriptor_set->GetChangeCount() ||
+                    (!disabled.image_layout_validation &&
+                     state.per_set[setIndex].validated_set_image_layout_change_count != cb_node->image_layout_change_count) ||
+                    // Revalidate if previous bindingReqMap doesn't include new bindingRepMap
+                    !std::includes(state.per_set[setIndex].validated_set_binding_req_map.begin(),
+                                   state.per_set[setIndex].validated_set_binding_req_map.end(), set_binding_pair.second.begin(),
+                                   set_binding_pair.second.end());
+
+                if (need_validate) {
+                    if (!ValidateDrawState(descriptor_set, binding_req_map, state.per_set[setIndex].dynamicOffsets, cb_node,
+                                           function, &err_str)) {
+                        auto set = descriptor_set->GetSet();
+                        result |=
+                            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+                                    HandleToUint64(set), kVUID_Core_DrawState_DescriptorSetNotUpdated,
+                                    "%s bound as set #%u encountered the following validation error at %s time: %s",
+                                    report_data->FormatHandle(set).c_str(), setIndex, function, err_str.c_str());
+                    }
                 }
             }
         }
@@ -1160,23 +1258,58 @@ bool CoreChecks::ValidateCmdBufDrawState(CMD_BUFFER_STATE *cb_node, CMD_TYPE cmd
     return result;
 }
 
-void CoreChecks::UpdateDrawState(CMD_BUFFER_STATE *cb_state, const VkPipelineBindPoint bind_point) {
-    auto const &state = cb_state->lastBound[bind_point];
+void ValidationStateTracker::UpdateDrawState(CMD_BUFFER_STATE *cb_state, const VkPipelineBindPoint bind_point) {
+    auto &state = cb_state->lastBound[bind_point];
     PIPELINE_STATE *pPipe = state.pipeline_state;
     if (VK_NULL_HANDLE != state.pipeline_layout) {
         for (const auto &set_binding_pair : pPipe->active_slots) {
             uint32_t setIndex = set_binding_pair.first;
             // Pull the set node
-            cvdescriptorset::DescriptorSet *descriptor_set = state.boundDescriptorSets[setIndex];
+            cvdescriptorset::DescriptorSet *descriptor_set = state.per_set[setIndex].bound_descriptor_set;
             if (!descriptor_set->IsPushDescriptor()) {
                 // For the "bindless" style resource usage with many descriptors, need to optimize command <-> descriptor binding
-                const cvdescriptorset::PrefilterBindRequestMap reduced_map(*descriptor_set, set_binding_pair.second, cb_state);
-                const auto &binding_req_map = reduced_map.Map();
 
-                // Bind this set and its active descriptor resources to the command buffer
-                descriptor_set->UpdateDrawState(this, cb_state, binding_req_map);
-                // For given active slots record updated images & buffers
-                descriptor_set->GetStorageUpdates(binding_req_map, &cb_state->updateBuffers, &cb_state->updateImages);
+                // TODO: If recreating the reduced_map here shows up in profilinging, need to find a way of sharing with the
+                // Validate pass.  Though in the case of "many" descriptors, typically the descriptor count >> binding count
+                cvdescriptorset::PrefilterBindRequestMap reduced_map(*descriptor_set, set_binding_pair.second);
+                const auto &binding_req_map = reduced_map.FilteredMap(*cb_state, *pPipe);
+
+                if (reduced_map.IsManyDescriptors()) {
+                    // Only update validate binding tags if we meet the "many" criteria in the Prefilter class
+                    descriptor_set->UpdateValidationCache(*cb_state, *pPipe, binding_req_map);
+                }
+
+                // We can skip updating the state if "nothing" has changed since the last validation.
+                // See CoreChecks::ValidateCmdBufDrawState for more details.
+                bool need_update =
+                    !reduced_map.IsManyDescriptors() ||
+                    // Update if descriptor set (or contents) has changed
+                    state.per_set[setIndex].validated_set != descriptor_set ||
+                    state.per_set[setIndex].validated_set_change_count != descriptor_set->GetChangeCount() ||
+                    (!disabled.image_layout_validation &&
+                     state.per_set[setIndex].validated_set_image_layout_change_count != cb_state->image_layout_change_count) ||
+                    // Update if previous bindingReqMap doesn't include new bindingRepMap
+                    !std::includes(state.per_set[setIndex].validated_set_binding_req_map.begin(),
+                                   state.per_set[setIndex].validated_set_binding_req_map.end(), set_binding_pair.second.begin(),
+                                   set_binding_pair.second.end());
+
+                if (need_update) {
+                    // Bind this set and its active descriptor resources to the command buffer
+                    descriptor_set->UpdateDrawState(this, cb_state, binding_req_map);
+
+                    state.per_set[setIndex].validated_set = descriptor_set;
+                    state.per_set[setIndex].validated_set_change_count = descriptor_set->GetChangeCount();
+                    state.per_set[setIndex].validated_set_image_layout_change_count = cb_state->image_layout_change_count;
+                    if (reduced_map.IsManyDescriptors()) {
+                        // Check whether old == new before assigning, the equality check is much cheaper than
+                        // freeing and reallocating the map.
+                        if (state.per_set[setIndex].validated_set_binding_req_map != set_binding_pair.second) {
+                            state.per_set[setIndex].validated_set_binding_req_map = set_binding_pair.second;
+                        }
+                    } else {
+                        state.per_set[setIndex].validated_set_binding_req_map = BindingReqMap();
+                    }
+                }
             }
         }
     }
@@ -1556,175 +1689,185 @@ bool CoreChecks::ValidatePipelineUnlocked(const PIPELINE_STATE *pPipeline, uint3
         }
     }
 
-    auto accumColorSamples = [subpass_desc, pPipeline](uint32_t &samples) {
-        for (uint32_t i = 0; i < subpass_desc->colorAttachmentCount; i++) {
-            const auto attachment = subpass_desc->pColorAttachments[i].attachment;
-            if (attachment != VK_ATTACHMENT_UNUSED) {
-                samples |= static_cast<uint32_t>(pPipeline->rp_state->createInfo.pAttachments[attachment].samples);
+    if (pPipeline->graphicsPipelineCI.pMultisampleState) {
+        auto accumColorSamples = [subpass_desc, pPipeline](uint32_t &samples) {
+            for (uint32_t i = 0; i < subpass_desc->colorAttachmentCount; i++) {
+                const auto attachment = subpass_desc->pColorAttachments[i].attachment;
+                if (attachment != VK_ATTACHMENT_UNUSED) {
+                    samples |= static_cast<uint32_t>(pPipeline->rp_state->createInfo.pAttachments[attachment].samples);
+                }
             }
-        }
-    };
+        };
 
-    if (!(device_extensions.vk_amd_mixed_attachment_samples || device_extensions.vk_nv_framebuffer_mixed_samples)) {
-        uint32_t raster_samples = static_cast<uint32_t>(GetNumSamples(pPipeline));
-        uint32_t subpass_num_samples = 0;
+        if (!(device_extensions.vk_amd_mixed_attachment_samples || device_extensions.vk_nv_framebuffer_mixed_samples)) {
+            uint32_t raster_samples = static_cast<uint32_t>(GetNumSamples(pPipeline));
+            uint32_t subpass_num_samples = 0;
 
-        accumColorSamples(subpass_num_samples);
+            accumColorSamples(subpass_num_samples);
 
-        if (subpass_desc->pDepthStencilAttachment && subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
-            const auto attachment = subpass_desc->pDepthStencilAttachment->attachment;
-            subpass_num_samples |= static_cast<uint32_t>(pPipeline->rp_state->createInfo.pAttachments[attachment].samples);
-        }
+            if (subpass_desc->pDepthStencilAttachment &&
+                subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
+                const auto attachment = subpass_desc->pDepthStencilAttachment->attachment;
+                subpass_num_samples |= static_cast<uint32_t>(pPipeline->rp_state->createInfo.pAttachments[attachment].samples);
+            }
 
-        // subpass_num_samples is 0 when the subpass has no attachments or if all attachments are VK_ATTACHMENT_UNUSED.
-        // Only validate the value of subpass_num_samples if the subpass has attachments that are not VK_ATTACHMENT_UNUSED.
-        if (subpass_num_samples && (!IsPowerOfTwo(subpass_num_samples) || (subpass_num_samples != raster_samples))) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-                            HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-00757",
-                            "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) "
-                            "does not match the number of samples of the RenderPass color and/or depth attachment.",
-                            pipelineIndex, raster_samples);
+            // subpass_num_samples is 0 when the subpass has no attachments or if all attachments are VK_ATTACHMENT_UNUSED.
+            // Only validate the value of subpass_num_samples if the subpass has attachments that are not VK_ATTACHMENT_UNUSED.
+            if (subpass_num_samples && (!IsPowerOfTwo(subpass_num_samples) || (subpass_num_samples != raster_samples))) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                                HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-00757",
+                                "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) "
+                                "does not match the number of samples of the RenderPass color and/or depth attachment.",
+                                pipelineIndex, raster_samples);
+            }
         }
-    }
 
-    if (device_extensions.vk_amd_mixed_attachment_samples) {
-        VkSampleCountFlagBits max_sample_count = static_cast<VkSampleCountFlagBits>(0);
-        for (uint32_t i = 0; i < subpass_desc->colorAttachmentCount; ++i) {
-            if (subpass_desc->pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED) {
-                max_sample_count =
-                    std::max(max_sample_count,
-                             pPipeline->rp_state->createInfo.pAttachments[subpass_desc->pColorAttachments[i].attachment].samples);
+        if (device_extensions.vk_amd_mixed_attachment_samples) {
+            VkSampleCountFlagBits max_sample_count = static_cast<VkSampleCountFlagBits>(0);
+            for (uint32_t i = 0; i < subpass_desc->colorAttachmentCount; ++i) {
+                if (subpass_desc->pColorAttachments[i].attachment != VK_ATTACHMENT_UNUSED) {
+                    max_sample_count = std::max(
+                        max_sample_count,
+                        pPipeline->rp_state->createInfo.pAttachments[subpass_desc->pColorAttachments[i].attachment].samples);
+                }
+            }
+            if (subpass_desc->pDepthStencilAttachment &&
+                subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
+                max_sample_count = std::max(
+                    max_sample_count,
+                    pPipeline->rp_state->createInfo.pAttachments[subpass_desc->pDepthStencilAttachment->attachment].samples);
+            }
+            if ((pPipeline->graphicsPipelineCI.pRasterizationState->rasterizerDiscardEnable == VK_FALSE) &&
+                (pPipeline->graphicsPipelineCI.pMultisampleState->rasterizationSamples != max_sample_count)) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                                HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-01505",
+                                "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%s) != max "
+                                "attachment samples (%s) used in subpass %u.",
+                                pipelineIndex,
+                                string_VkSampleCountFlagBits(pPipeline->graphicsPipelineCI.pMultisampleState->rasterizationSamples),
+                                string_VkSampleCountFlagBits(max_sample_count), pPipeline->graphicsPipelineCI.subpass);
             }
         }
-        if (subpass_desc->pDepthStencilAttachment && subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
-            max_sample_count =
-                std::max(max_sample_count,
-                         pPipeline->rp_state->createInfo.pAttachments[subpass_desc->pDepthStencilAttachment->attachment].samples);
-        }
-        if ((pPipeline->graphicsPipelineCI.pRasterizationState->rasterizerDiscardEnable == VK_FALSE) &&
-            (pPipeline->graphicsPipelineCI.pMultisampleState->rasterizationSamples != max_sample_count)) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-                            HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-01505",
-                            "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%s) != max "
-                            "attachment samples (%s) used in subpass %u.",
-                            pipelineIndex,
-                            string_VkSampleCountFlagBits(pPipeline->graphicsPipelineCI.pMultisampleState->rasterizationSamples),
-                            string_VkSampleCountFlagBits(max_sample_count), pPipeline->graphicsPipelineCI.subpass);
-        }
-    }
 
-    if (device_extensions.vk_nv_framebuffer_mixed_samples) {
-        uint32_t raster_samples = static_cast<uint32_t>(GetNumSamples(pPipeline));
-        uint32_t subpass_color_samples = 0;
+        if (device_extensions.vk_nv_framebuffer_mixed_samples) {
+            uint32_t raster_samples = static_cast<uint32_t>(GetNumSamples(pPipeline));
+            uint32_t subpass_color_samples = 0;
 
-        accumColorSamples(subpass_color_samples);
+            accumColorSamples(subpass_color_samples);
 
-        if (subpass_desc->pDepthStencilAttachment && subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
-            const auto attachment = subpass_desc->pDepthStencilAttachment->attachment;
-            const uint32_t subpass_depth_samples =
-                static_cast<uint32_t>(pPipeline->rp_state->createInfo.pAttachments[attachment].samples);
+            if (subpass_desc->pDepthStencilAttachment &&
+                subpass_desc->pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
+                const auto attachment = subpass_desc->pDepthStencilAttachment->attachment;
+                const uint32_t subpass_depth_samples =
+                    static_cast<uint32_t>(pPipeline->rp_state->createInfo.pAttachments[attachment].samples);
 
-            if (pPipeline->graphicsPipelineCI.pDepthStencilState) {
-                const bool ds_test_enabled = (pPipeline->graphicsPipelineCI.pDepthStencilState->depthTestEnable == VK_TRUE) ||
-                                             (pPipeline->graphicsPipelineCI.pDepthStencilState->depthBoundsTestEnable == VK_TRUE) ||
-                                             (pPipeline->graphicsPipelineCI.pDepthStencilState->stencilTestEnable == VK_TRUE);
+                if (pPipeline->graphicsPipelineCI.pDepthStencilState) {
+                    const bool ds_test_enabled =
+                        (pPipeline->graphicsPipelineCI.pDepthStencilState->depthTestEnable == VK_TRUE) ||
+                        (pPipeline->graphicsPipelineCI.pDepthStencilState->depthBoundsTestEnable == VK_TRUE) ||
+                        (pPipeline->graphicsPipelineCI.pDepthStencilState->stencilTestEnable == VK_TRUE);
 
-                if (ds_test_enabled && (!IsPowerOfTwo(subpass_depth_samples) || (raster_samples != subpass_depth_samples))) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-                                    HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-01411",
-                                    "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) "
-                                    "does not match the number of samples of the RenderPass depth attachment (%u).",
-                                    pipelineIndex, raster_samples, subpass_depth_samples);
+                    if (ds_test_enabled && (!IsPowerOfTwo(subpass_depth_samples) || (raster_samples != subpass_depth_samples))) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                                        HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-01411",
+                                        "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) "
+                                        "does not match the number of samples of the RenderPass depth attachment (%u).",
+                                        pipelineIndex, raster_samples, subpass_depth_samples);
+                    }
                 }
             }
-        }
 
-        if (IsPowerOfTwo(subpass_color_samples)) {
-            if (raster_samples < subpass_color_samples) {
-                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-                                HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-01412",
-                                "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) "
-                                "is not greater or equal to the number of samples of the RenderPass color attachment (%u).",
-                                pipelineIndex, raster_samples, subpass_color_samples);
-            }
-
-            if (pPipeline->graphicsPipelineCI.pMultisampleState) {
-                if ((raster_samples > subpass_color_samples) &&
-                    (pPipeline->graphicsPipelineCI.pMultisampleState->sampleShadingEnable == VK_TRUE)) {
-                    skip |= log_msg(
-                        report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
-                        "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415",
-                        "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->sampleShadingEnable must be VK_FALSE when "
-                        "pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) is greater than the number of samples of the "
-                        "subpass color attachment (%u).",
-                        pipelineIndex, pipelineIndex, raster_samples, subpass_color_samples);
+            if (IsPowerOfTwo(subpass_color_samples)) {
+                if (raster_samples < subpass_color_samples) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                                    HandleToUint64(device), "VUID-VkGraphicsPipelineCreateInfo-subpass-01412",
+                                    "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) "
+                                    "is not greater or equal to the number of samples of the RenderPass color attachment (%u).",
+                                    pipelineIndex, raster_samples, subpass_color_samples);
                 }
 
-                const auto *coverage_modulation_state = lvl_find_in_chain<VkPipelineCoverageModulationStateCreateInfoNV>(
-                    pPipeline->graphicsPipelineCI.pMultisampleState->pNext);
+                if (pPipeline->graphicsPipelineCI.pMultisampleState) {
+                    if ((raster_samples > subpass_color_samples) &&
+                        (pPipeline->graphicsPipelineCI.pMultisampleState->sampleShadingEnable == VK_TRUE)) {
+                        skip |=
+                            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                                    HandleToUint64(device), "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-01415",
+                                    "vkCreateGraphicsPipelines: pCreateInfo[%d].pMultisampleState->sampleShadingEnable must be "
+                                    "VK_FALSE when "
+                                    "pCreateInfo[%d].pMultisampleState->rasterizationSamples (%u) is greater than the number of "
+                                    "samples of the "
+                                    "subpass color attachment (%u).",
+                                    pipelineIndex, pipelineIndex, raster_samples, subpass_color_samples);
+                    }
+
+                    const auto *coverage_modulation_state = lvl_find_in_chain<VkPipelineCoverageModulationStateCreateInfoNV>(
+                        pPipeline->graphicsPipelineCI.pMultisampleState->pNext);
 
-                if (coverage_modulation_state && (coverage_modulation_state->coverageModulationTableEnable == VK_TRUE)) {
-                    if (coverage_modulation_state->coverageModulationTableCount != (raster_samples / subpass_color_samples)) {
-                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                    if (coverage_modulation_state && (coverage_modulation_state->coverageModulationTableEnable == VK_TRUE)) {
+                        if (coverage_modulation_state->coverageModulationTableCount != (raster_samples / subpass_color_samples)) {
+                            skip |=
+                                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
                                         HandleToUint64(device),
                                         "VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405",
                                         "vkCreateGraphicsPipelines: pCreateInfos[%d] VkPipelineCoverageModulationStateCreateInfoNV "
                                         "coverageModulationTableCount of %u is invalid.",
                                         pipelineIndex, coverage_modulation_state->coverageModulationTableCount);
+                        }
                     }
                 }
             }
         }
-    }
-
-    if (device_extensions.vk_nv_fragment_coverage_to_color) {
-        const auto coverage_to_color_state =
-            lvl_find_in_chain<VkPipelineCoverageToColorStateCreateInfoNV>(pPipeline->graphicsPipelineCI.pMultisampleState);
-
-        if (coverage_to_color_state && coverage_to_color_state->coverageToColorEnable == VK_TRUE) {
-            bool attachment_is_valid = false;
-            std::string error_detail;
-
-            if (coverage_to_color_state->coverageToColorLocation < subpass_desc->colorAttachmentCount) {
-                const auto color_attachment_ref = subpass_desc->pColorAttachments[coverage_to_color_state->coverageToColorLocation];
-                if (color_attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
-                    const auto color_attachment = pPipeline->rp_state->createInfo.pAttachments[color_attachment_ref.attachment];
 
-                    switch (color_attachment.format) {
-                        case VK_FORMAT_R8_UINT:
-                        case VK_FORMAT_R8_SINT:
-                        case VK_FORMAT_R16_UINT:
-                        case VK_FORMAT_R16_SINT:
-                        case VK_FORMAT_R32_UINT:
-                        case VK_FORMAT_R32_SINT:
-                            attachment_is_valid = true;
-                            break;
-                        default:
-                            string_sprintf(&error_detail, "references an attachment with an invalid format (%s).",
-                                           string_VkFormat(color_attachment.format));
-                            break;
+        if (device_extensions.vk_nv_fragment_coverage_to_color) {
+            const auto coverage_to_color_state =
+                lvl_find_in_chain<VkPipelineCoverageToColorStateCreateInfoNV>(pPipeline->graphicsPipelineCI.pMultisampleState);
+
+            if (coverage_to_color_state && coverage_to_color_state->coverageToColorEnable == VK_TRUE) {
+                bool attachment_is_valid = false;
+                std::string error_detail;
+
+                if (coverage_to_color_state->coverageToColorLocation < subpass_desc->colorAttachmentCount) {
+                    const auto color_attachment_ref =
+                        subpass_desc->pColorAttachments[coverage_to_color_state->coverageToColorLocation];
+                    if (color_attachment_ref.attachment != VK_ATTACHMENT_UNUSED) {
+                        const auto color_attachment = pPipeline->rp_state->createInfo.pAttachments[color_attachment_ref.attachment];
+
+                        switch (color_attachment.format) {
+                            case VK_FORMAT_R8_UINT:
+                            case VK_FORMAT_R8_SINT:
+                            case VK_FORMAT_R16_UINT:
+                            case VK_FORMAT_R16_SINT:
+                            case VK_FORMAT_R32_UINT:
+                            case VK_FORMAT_R32_SINT:
+                                attachment_is_valid = true;
+                                break;
+                            default:
+                                string_sprintf(&error_detail, "references an attachment with an invalid format (%s).",
+                                               string_VkFormat(color_attachment.format));
+                                break;
+                        }
+                    } else {
+                        string_sprintf(&error_detail,
+                                       "references an invalid attachment. The subpass pColorAttachments[%" PRIu32
+                                       "].attachment has the value "
+                                       "VK_ATTACHMENT_UNUSED.",
+                                       coverage_to_color_state->coverageToColorLocation);
                     }
                 } else {
                     string_sprintf(&error_detail,
-                                   "references an invalid attachment. The subpass pColorAttachments[%" PRIu32
-                                   "].attachment has the value "
-                                   "VK_ATTACHMENT_UNUSED.",
-                                   coverage_to_color_state->coverageToColorLocation);
+                                   "references an non-existing attachment since the subpass colorAttachmentCount is %" PRIu32 ".",
+                                   subpass_desc->colorAttachmentCount);
                 }
-            } else {
-                string_sprintf(&error_detail,
-                               "references an non-existing attachment since the subpass colorAttachmentCount is %" PRIu32 ".",
-                               subpass_desc->colorAttachmentCount);
-            }
 
-            if (!attachment_is_valid) {
-                skip |=
-                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
-                            HandleToUint64(device), "VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404",
-                            "vkCreateGraphicsPipelines: pCreateInfos[%" PRId32
-                            "].pMultisampleState VkPipelineCoverageToColorStateCreateInfoNV "
-                            "coverageToColorLocation = %" PRIu32 " %s",
-                            pipelineIndex, coverage_to_color_state->coverageToColorLocation, error_detail.c_str());
+                if (!attachment_is_valid) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                                    HandleToUint64(device),
+                                    "VUID-VkPipelineCoverageToColorStateCreateInfoNV-coverageToColorEnable-01404",
+                                    "vkCreateGraphicsPipelines: pCreateInfos[%" PRId32
+                                    "].pMultisampleState VkPipelineCoverageToColorStateCreateInfoNV "
+                                    "coverageToColorLocation = %" PRIu32 " %s",
+                                    pipelineIndex, coverage_to_color_state->coverageToColorLocation, error_detail.c_str());
+                }
             }
         }
     }
@@ -1887,7 +2030,7 @@ bool CoreChecks::ValidateDeviceMaskToZero(uint32_t deviceMask, VkDebugReportObje
 
 bool CoreChecks::ValidateDeviceMaskToCommandBuffer(const CMD_BUFFER_STATE *pCB, uint32_t deviceMask,
                                                    VkDebugReportObjectTypeEXT VUID_handle_type, uint64_t VUID_handle,
-                                                   const char *VUID) {
+                                                   const char *VUID) const {
     bool skip = false;
     if ((deviceMask & pCB->initial_device_mask) != deviceMask) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VUID_handle_type, VUID_handle, VUID,
@@ -1984,8 +2127,11 @@ BASE_NODE *ValidationStateTracker::GetStateStructPtrFromObject(const VulkanTyped
 // Tie the VulkanTypedHandle to the cmd buffer which includes:
 //  Add object_binding to cmd buffer
 //  Add cb_binding to object
-static void AddCommandBufferBinding(std::unordered_set<CMD_BUFFER_STATE *> *cb_bindings, const VulkanTypedHandle &obj,
-                                    CMD_BUFFER_STATE *cb_node) {
+void ValidationStateTracker::AddCommandBufferBinding(std::unordered_set<CMD_BUFFER_STATE *> *cb_bindings,
+                                                     const VulkanTypedHandle &obj, CMD_BUFFER_STATE *cb_node) {
+    if (disabled.command_buffer_state) {
+        return;
+    }
     cb_bindings->insert(cb_node);
     cb_node->object_bindings.insert(obj);
 }
@@ -2005,6 +2151,8 @@ void ValidationStateTracker::ResetCommandBufferState(const VkCommandBuffer cb) {
         memset(&pCB->beginInfo, 0, sizeof(VkCommandBufferBeginInfo));
         memset(&pCB->inheritanceInfo, 0, sizeof(VkCommandBufferInheritanceInfo));
         pCB->hasDrawCmd = false;
+        pCB->hasTraceRaysCmd = false;
+        pCB->hasDispatchCmd = false;
         pCB->state = CB_NEW;
         pCB->submitCount = 0;
         pCB->image_layout_change_count = 1;  // Start at 1. 0 is insert value for validation cache versions, s.t. new == dirty
@@ -2030,8 +2178,8 @@ void ValidationStateTracker::ResetCommandBufferState(const VkCommandBuffer cb) {
         pCB->startedQueries.clear();
         pCB->image_layout_map.clear();
         pCB->eventToStageMap.clear();
-        pCB->draw_data.clear();
-        pCB->current_draw_data.vertex_buffer_bindings.clear();
+        pCB->cb_vertex_buffer_binding_info.clear();
+        pCB->current_vertex_buffer_binding_info.vertex_buffer_bindings.clear();
         pCB->vertex_buffer_used = false;
         pCB->primaryCommandBuffer = VK_NULL_HANDLE;
         // If secondary, invalidate any primary command buffer that may call us.
@@ -2044,8 +2192,6 @@ void ValidationStateTracker::ResetCommandBufferState(const VkCommandBuffer cb) {
             pSubCB->linkedCommandBuffers.erase(pCB);
         }
         pCB->linkedCommandBuffers.clear();
-        pCB->updateImages.clear();
-        pCB->updateBuffers.clear();
         ClearCmdBufAndMemReferences(pCB);
         pCB->queue_submit_functions.clear();
         pCB->cmd_execute_commands_functions.clear();
@@ -2118,6 +2264,9 @@ CBStatusFlags MakeStaticStateMask(VkPipelineDynamicStateCreateInfo const *ds) {
                 case VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV:
                     flags &= ~CBSTATUS_SHADING_RATE_PALETTE_SET;
                     break;
+                case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
+                    flags &= ~CBSTATUS_LINE_STIPPLE_SET;
+                    break;
                 default:
                     break;
             }
@@ -2268,14 +2417,15 @@ bool CoreChecks::PreCallValidateCreateDevice(VkPhysicalDevice gpu, const VkDevic
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0,
                         kVUID_Core_DevLimit_MustQueryCount,
                         "Invalid call to vkCreateDevice() w/o first calling vkEnumeratePhysicalDevices().");
+    } else {
+        skip |= ValidateDeviceQueueCreateInfos(pd_state, pCreateInfo->queueCreateInfoCount, pCreateInfo->pQueueCreateInfos);
     }
-    skip |= ValidateDeviceQueueCreateInfos(pd_state, pCreateInfo->queueCreateInfoCount, pCreateInfo->pQueueCreateInfos);
     return skip;
 }
 
 void CoreChecks::PreCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
                                            const VkAllocationCallbacks *pAllocator, VkDevice *pDevice,
-                                           std::unique_ptr<safe_VkDeviceCreateInfo> &modified_create_info) {
+                                           safe_VkDeviceCreateInfo *modified_create_info) {
     // GPU Validation can possibly turn on device features, so give it a chance to change the create info.
     if (enabled.gpu_validation) {
         VkPhysicalDeviceFeatures supported_features;
@@ -2289,15 +2439,23 @@ void CoreChecks::PostCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDevice
     // The state tracker sets up the device state
     StateTracker::PostCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice, result);
 
+    // Add the callback hooks for the functions that are either broadly or deeply used and that the ValidationStateTracker refactor
+    // would be messier without.
+    // TODO: Find a good way to do this hooklessly.
+    ValidationObject *device_object = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
+    ValidationObject *validation_data = GetValidationObject(device_object->object_dispatch, LayerObjectTypeCoreValidation);
+    CoreChecks *core_checks = static_cast<CoreChecks *>(validation_data);
+
     if (enabled.gpu_validation) {
         // The only CoreCheck specific init is for gpu_validation
-        ValidationObject *device_object = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
-        ValidationObject *validation_data = GetValidationObject(device_object->object_dispatch, LayerObjectTypeCoreValidation);
-        CoreChecks *core_checks = static_cast<CoreChecks *>(validation_data);
         core_checks->GpuPostCallRecordCreateDevice(&enabled, pCreateInfo);
         core_checks->SetCommandBufferResetCallback(
             [core_checks](VkCommandBuffer command_buffer) -> void { core_checks->GpuResetCommandBuffer(command_buffer); });
     }
+    core_checks->SetSetImageViewInitialLayoutCallback(
+        [core_checks](CMD_BUFFER_STATE *cb_node, const IMAGE_VIEW_STATE &iv_state, VkImageLayout layout) -> void {
+            core_checks->SetImageViewInitialLayout(cb_node, iv_state, layout);
+        });
 }
 
 void ValidationStateTracker::PostCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo *pCreateInfo,
@@ -2438,6 +2596,30 @@ void ValidationStateTracker::PostCallRecordCreateDevice(VkPhysicalDevice gpu, co
         state_tracker->enabled_features.fragment_shader_interlock_features = *fragment_shader_interlock_features;
     }
 
+    const auto *demote_to_helper_invocation_features =
+        lvl_find_in_chain<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>(pCreateInfo->pNext);
+    if (demote_to_helper_invocation_features) {
+        state_tracker->enabled_features.demote_to_helper_invocation_features = *demote_to_helper_invocation_features;
+    }
+
+    const auto *texel_buffer_alignment_features =
+        lvl_find_in_chain<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(pCreateInfo->pNext);
+    if (texel_buffer_alignment_features) {
+        state_tracker->enabled_features.texel_buffer_alignment_features = *texel_buffer_alignment_features;
+    }
+
+    const auto *imageless_framebuffer_features =
+        lvl_find_in_chain<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>(pCreateInfo->pNext);
+    if (imageless_framebuffer_features) {
+        state_tracker->enabled_features.imageless_framebuffer_features = *imageless_framebuffer_features;
+    }
+
+    const auto *pipeline_exe_props_features =
+        lvl_find_in_chain<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(pCreateInfo->pNext);
+    if (pipeline_exe_props_features) {
+        state_tracker->enabled_features.pipeline_exe_props_features = *pipeline_exe_props_features;
+    }
+
     // Store physical device properties and physical device mem limits into CoreChecks structs
     DispatchGetPhysicalDeviceMemoryProperties(gpu, &state_tracker->phys_dev_mem_props);
     DispatchGetPhysicalDeviceProperties(gpu, &state_tracker->phys_dev_props);
@@ -2460,6 +2642,8 @@ void ValidationStateTracker::PostCallRecordCreateDevice(VkPhysicalDevice gpu, co
     GetPhysicalDeviceExtProperties(gpu, dev_ext.vk_khr_depth_stencil_resolve, &phys_dev_props->depth_stencil_resolve_props);
     GetPhysicalDeviceExtProperties(gpu, dev_ext.vk_ext_transform_feedback, &phys_dev_props->transform_feedback_props);
     GetPhysicalDeviceExtProperties(gpu, dev_ext.vk_nv_ray_tracing, &phys_dev_props->ray_tracing_props);
+    GetPhysicalDeviceExtProperties(gpu, dev_ext.vk_ext_texel_buffer_alignment, &phys_dev_props->texel_buffer_alignment_props);
+    GetPhysicalDeviceExtProperties(gpu, dev_ext.vk_ext_fragment_density_map, &phys_dev_props->fragment_density_map_props);
     if (state_tracker->device_extensions.vk_nv_cooperative_matrix) {
         // Get the needed cooperative_matrix properties
         auto cooperative_matrix_props = lvl_init_struct<VkPhysicalDeviceCooperativeMatrixPropertiesNV>();
@@ -2498,7 +2682,13 @@ void ValidationStateTracker::PreCallRecordDestroyDevice(VkDevice device, const V
 
     pipelineMap.clear();
     renderPassMap.clear();
+
+    // Reset all command buffers before destroying them, to unlink object_bindings.
+    for (auto &commandBuffer : commandBufferMap) {
+        ResetCommandBufferState(commandBuffer.first);
+    }
     commandBufferMap.clear();
+
     // This will also delete all sets in the pool & remove them from setMap
     DeleteDescriptorSetPools();
     // All sets should be removed
@@ -2506,7 +2696,6 @@ void ValidationStateTracker::PreCallRecordDestroyDevice(VkDevice device, const V
     descriptorSetLayoutMap.clear();
     imageViewMap.clear();
     imageMap.clear();
-    imageLayoutMap.clear();
     bufferViewMap.clear();
     bufferMap.clear();
     // Queues persist until device is destroyed
@@ -2519,6 +2708,7 @@ void CoreChecks::PreCallRecordDestroyDevice(VkDevice device, const VkAllocationC
         GpuPreCallRecordDestroyDevice();
     }
     imageSubresourceMap.clear();
+    imageLayoutMap.clear();
 
     StateTracker::PreCallRecordDestroyDevice(device, pAllocator);
 }
@@ -2527,7 +2717,8 @@ void CoreChecks::PreCallRecordDestroyDevice(VkDevice device, const VkAllocationC
 //   and if Tessellation Control or Evaluation shader stages are on w/o TS being enabled, report tess_error_id.
 // Similarly for mesh and task shaders.
 bool CoreChecks::ValidateStageMaskGsTsEnables(VkPipelineStageFlags stageMask, const char *caller, const char *geo_error_id,
-                                              const char *tess_error_id, const char *mesh_error_id, const char *task_error_id) {
+                                              const char *tess_error_id, const char *mesh_error_id,
+                                              const char *task_error_id) const {
     bool skip = false;
     if (!enabled_features.core.geometryShader && (stageMask & VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT)) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, geo_error_id,
@@ -2559,7 +2750,7 @@ bool CoreChecks::ValidateStageMaskGsTsEnables(VkPipelineStageFlags stageMask, co
 }
 
 // Loop through bound objects and increment their in_use counts.
-void CoreChecks::IncrementBoundObjects(CMD_BUFFER_STATE const *cb_node) {
+void ValidationStateTracker::IncrementBoundObjects(CMD_BUFFER_STATE const *cb_node) {
     for (auto obj : cb_node->object_bindings) {
         auto base_obj = GetStateStructPtrFromObject(obj);
         if (base_obj) {
@@ -2568,7 +2759,7 @@ void CoreChecks::IncrementBoundObjects(CMD_BUFFER_STATE const *cb_node) {
     }
 }
 // Track which resources are in-flight by atomically incrementing their "in_use" count
-void CoreChecks::IncrementResources(CMD_BUFFER_STATE *cb_node) {
+void ValidationStateTracker::IncrementResources(CMD_BUFFER_STATE *cb_node) {
     cb_node->submitCount++;
     cb_node->in_use.fetch_add(1);
 
@@ -2577,14 +2768,6 @@ void CoreChecks::IncrementResources(CMD_BUFFER_STATE *cb_node) {
     // TODO : We should be able to remove the NULL look-up checks from the code below as long as
     //  all the corresponding cases are verified to cause CB_INVALID state and the CB_INVALID state
     //  should then be flagged prior to calling this function
-    for (auto draw_data_element : cb_node->draw_data) {
-        for (auto &vertex_buffer : draw_data_element.vertex_buffer_bindings) {
-            auto buffer_state = GetBufferState(vertex_buffer.buffer);
-            if (buffer_state) {
-                buffer_state->in_use.fetch_add(1);
-            }
-        }
-    }
     for (auto event : cb_node->writeEventsBeforeWait) {
         auto event_state = GetEventState(event);
         if (event_state) event_state->write_in_use++;
@@ -2648,7 +2831,7 @@ bool CoreChecks::VerifyQueueStateToFence(VkFence fence) {
 }
 
 // Decrement in-use count for objects bound to command buffer
-void CoreChecks::DecrementBoundResources(CMD_BUFFER_STATE const *cb_node) {
+void ValidationStateTracker::DecrementBoundResources(CMD_BUFFER_STATE const *cb_node) {
     BASE_NODE *base_obj = nullptr;
     for (auto obj : cb_node->object_bindings) {
         base_obj = GetStateStructPtrFromObject(obj);
@@ -2658,7 +2841,7 @@ void CoreChecks::DecrementBoundResources(CMD_BUFFER_STATE const *cb_node) {
     }
 }
 
-void CoreChecks::RetireWorkOnQueue(QUEUE_STATE *pQueue, uint64_t seq) {
+void ValidationStateTracker::RetireWorkOnQueue(QUEUE_STATE *pQueue, uint64_t seq, bool switch_finished_queries) {
     std::unordered_map<VkQueue, uint64_t> otherQueueSeqs;
 
     // Roll this queue forward, one submission at a time.
@@ -2695,14 +2878,6 @@ void CoreChecks::RetireWorkOnQueue(QUEUE_STATE *pQueue, uint64_t seq) {
             }
             // First perform decrement on general case bound objects
             DecrementBoundResources(cb_node);
-            for (auto draw_data_element : cb_node->draw_data) {
-                for (auto &vertex_buffer_binding : draw_data_element.vertex_buffer_bindings) {
-                    auto buffer_state = GetBufferState(vertex_buffer_binding.buffer);
-                    if (buffer_state) {
-                        buffer_state->in_use.fetch_sub(1);
-                    }
-                }
-            }
             for (auto event : cb_node->writeEventsBeforeWait) {
                 auto eventNode = eventMap.find(event);
                 if (eventNode != eventMap.end()) {
@@ -2710,7 +2885,11 @@ void CoreChecks::RetireWorkOnQueue(QUEUE_STATE *pQueue, uint64_t seq) {
                 }
             }
             for (auto queryStatePair : cb_node->queryToStateMap) {
-                queryToStateMap[queryStatePair.first] = queryStatePair.second;
+                const QueryState newState =
+                    ((queryStatePair.second == QUERYSTATE_ENDED && switch_finished_queries) ? QUERYSTATE_AVAILABLE
+                                                                                            : queryStatePair.second);
+                pQueue->queryToStateMap[queryStatePair.first] = newState;
+                queryToStateMap[queryStatePair.first] = newState;
             }
             for (auto eventStagePair : cb_node->eventToStageMap) {
                 eventMap[eventStagePair.first].stageMask = eventStagePair.second;
@@ -2730,7 +2909,7 @@ void CoreChecks::RetireWorkOnQueue(QUEUE_STATE *pQueue, uint64_t seq) {
 
     // Roll other queues forward to the highest seq we saw a wait for
     for (auto qs : otherQueueSeqs) {
-        RetireWorkOnQueue(GetQueueState(qs.first), qs.second);
+        RetireWorkOnQueue(GetQueueState(qs.first), qs.second, switch_finished_queries);
     }
 }
 
@@ -2742,7 +2921,7 @@ static void SubmitFence(QUEUE_STATE *pQueue, FENCE_STATE *pFence, uint64_t submi
     pFence->signaler.second = pQueue->seq + pQueue->submissions.size() + submitCount;
 }
 
-bool CoreChecks::ValidateCommandBufferSimultaneousUse(CMD_BUFFER_STATE *pCB, int current_submit_count) {
+bool CoreChecks::ValidateCommandBufferSimultaneousUse(const CMD_BUFFER_STATE *pCB, int current_submit_count) const {
     bool skip = false;
     if ((pCB->in_use.load() || current_submit_count > 1) &&
         !(pCB->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)) {
@@ -2753,8 +2932,8 @@ bool CoreChecks::ValidateCommandBufferSimultaneousUse(CMD_BUFFER_STATE *pCB, int
     return skip;
 }
 
-bool CoreChecks::ValidateCommandBufferState(CMD_BUFFER_STATE *cb_state, const char *call_source, int current_submit_count,
-                                            const char *vu_id) {
+bool CoreChecks::ValidateCommandBufferState(const CMD_BUFFER_STATE *cb_state, const char *call_source, int current_submit_count,
+                                            const char *vu_id) const {
     bool skip = false;
     if (disabled.command_buffer_state) return skip;
     // Validate ONE_TIME_SUBMIT_BIT CB is not being submitted more than once
@@ -2794,29 +2973,9 @@ bool CoreChecks::ValidateCommandBufferState(CMD_BUFFER_STATE *cb_state, const ch
     return skip;
 }
 
-bool CoreChecks::ValidateResources(CMD_BUFFER_STATE *cb_node) {
-    bool skip = false;
-
-    // TODO : We should be able to remove the NULL look-up checks from the code below as long as
-    //  all the corresponding cases are verified to cause CB_INVALID state and the CB_INVALID state
-    //  should then be flagged prior to calling this function
-    for (const auto &draw_data_element : cb_node->draw_data) {
-        for (const auto &vertex_buffer_binding : draw_data_element.vertex_buffer_bindings) {
-            auto buffer_state = GetBufferState(vertex_buffer_binding.buffer);
-            if ((vertex_buffer_binding.buffer != VK_NULL_HANDLE) && (!buffer_state)) {
-                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
-                                HandleToUint64(vertex_buffer_binding.buffer), kVUID_Core_DrawState_InvalidBuffer,
-                                "Cannot submit cmd buffer using deleted %s.",
-                                report_data->FormatHandle(vertex_buffer_binding.buffer).c_str());
-            }
-        }
-    }
-    return skip;
-}
-
 // Check that the queue family index of 'queue' matches one of the entries in pQueueFamilyIndices
-bool CoreChecks::ValidImageBufferQueue(CMD_BUFFER_STATE *cb_node, const VulkanTypedHandle &object, VkQueue queue, uint32_t count,
-                                       const uint32_t *indices) {
+bool CoreChecks::ValidImageBufferQueue(const CMD_BUFFER_STATE *cb_node, const VulkanTypedHandle &object, VkQueue queue,
+                                       uint32_t count, const uint32_t *indices) const {
     bool found = false;
     bool skip = false;
     auto queue_state = GetQueueState(queue);
@@ -2842,7 +3001,7 @@ bool CoreChecks::ValidImageBufferQueue(CMD_BUFFER_STATE *cb_node, const VulkanTy
 
 // Validate that queueFamilyIndices of primary command buffers match this queue
 // Secondary command buffers were previously validated in vkCmdExecuteCommands().
-bool CoreChecks::ValidateQueueFamilyIndices(CMD_BUFFER_STATE *pCB, VkQueue queue) {
+bool CoreChecks::ValidateQueueFamilyIndices(const CMD_BUFFER_STATE *pCB, VkQueue queue) const {
     bool skip = false;
     auto pPool = GetCommandPoolState(pCB->createInfo.commandPool);
     auto queue_state = GetQueueState(queue);
@@ -2878,21 +3037,18 @@ bool CoreChecks::ValidateQueueFamilyIndices(CMD_BUFFER_STATE *pCB, VkQueue queue
     return skip;
 }
 
-bool CoreChecks::ValidatePrimaryCommandBufferState(CMD_BUFFER_STATE *pCB, int current_submit_count,
+bool CoreChecks::ValidatePrimaryCommandBufferState(const CMD_BUFFER_STATE *pCB, int current_submit_count,
                                                    QFOTransferCBScoreboards<VkImageMemoryBarrier> *qfo_image_scoreboards,
-                                                   QFOTransferCBScoreboards<VkBufferMemoryBarrier> *qfo_buffer_scoreboards) {
+                                                   QFOTransferCBScoreboards<VkBufferMemoryBarrier> *qfo_buffer_scoreboards) const {
     // Track in-use for resources off of primary and any secondary CBs
     bool skip = false;
 
-    // If USAGE_SIMULTANEOUS_USE_BIT not set then CB cannot already be executing
-    // on device
+    // If USAGE_SIMULTANEOUS_USE_BIT not set then CB cannot already be executing on device
     skip |= ValidateCommandBufferSimultaneousUse(pCB, current_submit_count);
 
-    skip |= ValidateResources(pCB);
     skip |= ValidateQueuedQFOTransfers(pCB, qfo_image_scoreboards, qfo_buffer_scoreboards);
 
     for (auto pSubCB : pCB->linkedCommandBuffers) {
-        skip |= ValidateResources(pSubCB);
         skip |= ValidateQueuedQFOTransfers(pSubCB, qfo_image_scoreboards, qfo_buffer_scoreboards);
         // TODO: replace with InvalidateCommandBuffers() at recording.
         if ((pSubCB->primaryCommandBuffer != pCB->commandBuffer) &&
@@ -2911,7 +3067,7 @@ bool CoreChecks::ValidatePrimaryCommandBufferState(CMD_BUFFER_STATE *pCB, int cu
     return skip;
 }
 
-bool CoreChecks::ValidateFenceForSubmit(FENCE_STATE *pFence) {
+bool CoreChecks::ValidateFenceForSubmit(const FENCE_STATE *pFence) const {
     bool skip = false;
 
     if (pFence && pFence->scope == kSyncScopeInternal) {
@@ -2936,8 +3092,8 @@ bool CoreChecks::ValidateFenceForSubmit(FENCE_STATE *pFence) {
     return skip;
 }
 
-void CoreChecks::PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence,
-                                           VkResult result) {
+void ValidationStateTracker::PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
+                                                       VkFence fence, VkResult result) {
     uint64_t early_retire_seq = 0;
     auto pQueue = GetQueueState(queue);
     auto pFence = GetFenceState(fence);
@@ -3024,13 +3180,9 @@ void CoreChecks::PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount,
                 cbs.push_back(submit->pCommandBuffers[i]);
                 for (auto secondaryCmdBuffer : cb_node->linkedCommandBuffers) {
                     cbs.push_back(secondaryCmdBuffer->commandBuffer);
-                    UpdateCmdBufImageLayouts(secondaryCmdBuffer);
                     IncrementResources(secondaryCmdBuffer);
-                    RecordQueuedQFOTransfers(secondaryCmdBuffer);
                 }
-                UpdateCmdBufImageLayouts(cb_node);
                 IncrementResources(cb_node);
-                RecordQueuedQFOTransfers(cb_node);
             }
         }
         pQueue->submissions.emplace_back(cbs, semaphore_waits, semaphore_signals, semaphore_externals,
@@ -3038,16 +3190,128 @@ void CoreChecks::PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount,
     }
 
     if (early_retire_seq) {
-        RetireWorkOnQueue(pQueue, early_retire_seq);
+        RetireWorkOnQueue(pQueue, early_retire_seq, true);
+    }
+}
+
+void CoreChecks::PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence,
+                                           VkResult result) {
+    StateTracker::PostCallRecordQueueSubmit(queue, submitCount, pSubmits, fence, result);
+
+    // The triply nested for duplicates that in the StateTracker, but avoids the need for two additional callbacks.
+    for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) {
+        const VkSubmitInfo *submit = &pSubmits[submit_idx];
+        for (uint32_t i = 0; i < submit->commandBufferCount; i++) {
+            auto cb_node = GetCBState(submit->pCommandBuffers[i]);
+            if (cb_node) {
+                for (auto secondaryCmdBuffer : cb_node->linkedCommandBuffers) {
+                    UpdateCmdBufImageLayouts(secondaryCmdBuffer);
+                    RecordQueuedQFOTransfers(secondaryCmdBuffer);
+                }
+                UpdateCmdBufImageLayouts(cb_node);
+                RecordQueuedQFOTransfers(cb_node);
+            }
+        }
     }
 
     if (enabled.gpu_validation) {
         GpuPostCallQueueSubmit(queue, submitCount, pSubmits, fence);
     }
 }
+bool CoreChecks::ValidateSemaphoresForSubmit(VkQueue queue, const VkSubmitInfo *submit,
+                                             unordered_set<VkSemaphore> *unsignaled_sema_arg,
+                                             unordered_set<VkSemaphore> *signaled_sema_arg,
+                                             unordered_set<VkSemaphore> *internal_sema_arg) const {
+    bool skip = false;
+    unordered_set<VkSemaphore> &signaled_semaphores = *signaled_sema_arg;
+    unordered_set<VkSemaphore> &unsignaled_semaphores = *unsignaled_sema_arg;
+    unordered_set<VkSemaphore> &internal_semaphores = *internal_sema_arg;
+
+    for (uint32_t i = 0; i < submit->waitSemaphoreCount; ++i) {
+        skip |=
+            ValidateStageMaskGsTsEnables(submit->pWaitDstStageMask[i], "vkQueueSubmit()",
+                                         "VUID-VkSubmitInfo-pWaitDstStageMask-00076", "VUID-VkSubmitInfo-pWaitDstStageMask-00077",
+                                         "VUID-VkSubmitInfo-pWaitDstStageMask-02089", "VUID-VkSubmitInfo-pWaitDstStageMask-02090");
+        VkSemaphore semaphore = submit->pWaitSemaphores[i];
+        const auto *pSemaphore = GetSemaphoreState(semaphore);
+        if (pSemaphore && (pSemaphore->scope == kSyncScopeInternal || internal_semaphores.count(semaphore))) {
+            if (unsignaled_semaphores.count(semaphore) || (!(signaled_semaphores.count(semaphore)) && !(pSemaphore->signaled))) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
+                                HandleToUint64(semaphore), kVUID_Core_DrawState_QueueForwardProgress,
+                                "%s is waiting on %s that has no way to be signaled.", report_data->FormatHandle(queue).c_str(),
+                                report_data->FormatHandle(semaphore).c_str());
+            } else {
+                signaled_semaphores.erase(semaphore);
+                unsignaled_semaphores.insert(semaphore);
+            }
+        }
+        if (pSemaphore && pSemaphore->scope == kSyncScopeExternalTemporary) {
+            internal_semaphores.insert(semaphore);
+        }
+    }
+    for (uint32_t i = 0; i < submit->signalSemaphoreCount; ++i) {
+        VkSemaphore semaphore = submit->pSignalSemaphores[i];
+        const auto *pSemaphore = GetSemaphoreState(semaphore);
+        if (pSemaphore && (pSemaphore->scope == kSyncScopeInternal || internal_semaphores.count(semaphore))) {
+            if (signaled_semaphores.count(semaphore) || (!(unsignaled_semaphores.count(semaphore)) && pSemaphore->signaled)) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
+                                HandleToUint64(semaphore), kVUID_Core_DrawState_QueueForwardProgress,
+                                "%s is signaling %s that was previously signaled by %s but has not since "
+                                "been waited on by any queue.",
+                                report_data->FormatHandle(queue).c_str(), report_data->FormatHandle(semaphore).c_str(),
+                                report_data->FormatHandle(pSemaphore->signaler.first).c_str());
+            } else {
+                unsignaled_semaphores.erase(semaphore);
+                signaled_semaphores.insert(semaphore);
+            }
+        }
+    }
+
+    return skip;
+}
+bool CoreChecks::ValidateCommandBuffersForSubmit(VkQueue queue, const VkSubmitInfo *submit,
+                                                 ImageSubresPairLayoutMap *localImageLayoutMap_arg,
+                                                 vector<VkCommandBuffer> *current_cmds_arg) const {
+    bool skip = false;
+
+    ImageSubresPairLayoutMap &localImageLayoutMap = *localImageLayoutMap_arg;
+    vector<VkCommandBuffer> &current_cmds = *current_cmds_arg;
+
+    QFOTransferCBScoreboards<VkImageMemoryBarrier> qfo_image_scoreboards;
+    QFOTransferCBScoreboards<VkBufferMemoryBarrier> qfo_buffer_scoreboards;
+
+    for (uint32_t i = 0; i < submit->commandBufferCount; i++) {
+        const auto *cb_node = GetCBState(submit->pCommandBuffers[i]);
+        if (cb_node) {
+            skip |= ValidateCmdBufImageLayouts(cb_node, imageLayoutMap, &localImageLayoutMap);
+            current_cmds.push_back(submit->pCommandBuffers[i]);
+            skip |= ValidatePrimaryCommandBufferState(
+                cb_node, (int)std::count(current_cmds.begin(), current_cmds.end(), submit->pCommandBuffers[i]),
+                &qfo_image_scoreboards, &qfo_buffer_scoreboards);
+            skip |= ValidateQueueFamilyIndices(cb_node, queue);
+
+            // Potential early exit here as bad object state may crash in delayed function calls
+            if (skip) {
+                return true;
+            }
+
+            // Call submit-time functions to validate/update state
+            for (auto &function : cb_node->queue_submit_functions) {
+                skip |= function();
+            }
+            for (auto &function : cb_node->eventUpdates) {
+                skip |= function(queue);
+            }
+            for (auto &function : cb_node->queryUpdates) {
+                skip |= function(queue);
+            }
+        }
+    }
+    return skip;
+}
 
 bool CoreChecks::PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, VkFence fence) {
-    auto pFence = GetFenceState(fence);
+    const auto *pFence = GetFenceState(fence);
     bool skip = ValidateFenceForSubmit(pFence);
     if (skip) {
         return true;
@@ -3057,80 +3321,13 @@ bool CoreChecks::PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount,
     unordered_set<VkSemaphore> unsignaled_semaphores;
     unordered_set<VkSemaphore> internal_semaphores;
     vector<VkCommandBuffer> current_cmds;
-    unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> localImageLayoutMap;
+    ImageSubresPairLayoutMap localImageLayoutMap;
     // Now verify each individual submit
     for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) {
         const VkSubmitInfo *submit = &pSubmits[submit_idx];
-        for (uint32_t i = 0; i < submit->waitSemaphoreCount; ++i) {
-            skip |= ValidateStageMaskGsTsEnables(
-                submit->pWaitDstStageMask[i], "vkQueueSubmit()", "VUID-VkSubmitInfo-pWaitDstStageMask-00076",
-                "VUID-VkSubmitInfo-pWaitDstStageMask-00077", "VUID-VkSubmitInfo-pWaitDstStageMask-02089",
-                "VUID-VkSubmitInfo-pWaitDstStageMask-02090");
-            VkSemaphore semaphore = submit->pWaitSemaphores[i];
-            auto pSemaphore = GetSemaphoreState(semaphore);
-            if (pSemaphore && (pSemaphore->scope == kSyncScopeInternal || internal_semaphores.count(semaphore))) {
-                if (unsignaled_semaphores.count(semaphore) ||
-                    (!(signaled_semaphores.count(semaphore)) && !(pSemaphore->signaled))) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
-                                    HandleToUint64(semaphore), kVUID_Core_DrawState_QueueForwardProgress,
-                                    "%s is waiting on %s that has no way to be signaled.", report_data->FormatHandle(queue).c_str(),
-                                    report_data->FormatHandle(semaphore).c_str());
-                } else {
-                    signaled_semaphores.erase(semaphore);
-                    unsignaled_semaphores.insert(semaphore);
-                }
-            }
-            if (pSemaphore && pSemaphore->scope == kSyncScopeExternalTemporary) {
-                internal_semaphores.insert(semaphore);
-            }
-        }
-        for (uint32_t i = 0; i < submit->signalSemaphoreCount; ++i) {
-            VkSemaphore semaphore = submit->pSignalSemaphores[i];
-            auto pSemaphore = GetSemaphoreState(semaphore);
-            if (pSemaphore && (pSemaphore->scope == kSyncScopeInternal || internal_semaphores.count(semaphore))) {
-                if (signaled_semaphores.count(semaphore) || (!(unsignaled_semaphores.count(semaphore)) && pSemaphore->signaled)) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
-                                    HandleToUint64(semaphore), kVUID_Core_DrawState_QueueForwardProgress,
-                                    "%s is signaling %s that was previously signaled by %s but has not since "
-                                    "been waited on by any queue.",
-                                    report_data->FormatHandle(queue).c_str(), report_data->FormatHandle(semaphore).c_str(),
-                                    report_data->FormatHandle(pSemaphore->signaler.first).c_str());
-                } else {
-                    unsignaled_semaphores.erase(semaphore);
-                    signaled_semaphores.insert(semaphore);
-                }
-            }
-        }
-        QFOTransferCBScoreboards<VkImageMemoryBarrier> qfo_image_scoreboards;
-        QFOTransferCBScoreboards<VkBufferMemoryBarrier> qfo_buffer_scoreboards;
+        skip |= ValidateSemaphoresForSubmit(queue, submit, &unsignaled_semaphores, &signaled_semaphores, &internal_semaphores);
+        skip |= ValidateCommandBuffersForSubmit(queue, submit, &localImageLayoutMap, &current_cmds);
 
-        for (uint32_t i = 0; i < submit->commandBufferCount; i++) {
-            auto cb_node = GetCBState(submit->pCommandBuffers[i]);
-            if (cb_node) {
-                skip |= ValidateCmdBufImageLayouts(cb_node, imageLayoutMap, localImageLayoutMap);
-                current_cmds.push_back(submit->pCommandBuffers[i]);
-                skip |= ValidatePrimaryCommandBufferState(
-                    cb_node, (int)std::count(current_cmds.begin(), current_cmds.end(), submit->pCommandBuffers[i]),
-                    &qfo_image_scoreboards, &qfo_buffer_scoreboards);
-                skip |= ValidateQueueFamilyIndices(cb_node, queue);
-
-                // Potential early exit here as bad object state may crash in delayed function calls
-                if (skip) {
-                    return true;
-                }
-
-                // Call submit-time functions to validate/update state
-                for (auto &function : cb_node->queue_submit_functions) {
-                    skip |= function();
-                }
-                for (auto &function : cb_node->eventUpdates) {
-                    skip |= function(queue);
-                }
-                for (auto &function : cb_node->queryUpdates) {
-                    skip |= function(queue);
-                }
-            }
-        }
         auto chained_device_group_struct = lvl_find_in_chain<VkDeviceGroupSubmitInfo>(submit->pNext);
         if (chained_device_group_struct && chained_device_group_struct->commandBufferCount > 0) {
             for (uint32_t i = 0; i < chained_device_group_struct->commandBufferCount; ++i) {
@@ -3265,7 +3462,7 @@ bool CoreChecks::PreCallValidateGetMemoryAndroidHardwareBufferANDROID(VkDevice d
                                                                       const VkMemoryGetAndroidHardwareBufferInfoANDROID *pInfo,
                                                                       struct AHardwareBuffer **pBuffer) {
     bool skip = false;
-    DEVICE_MEMORY_STATE *mem_info = GetDevMemState(pInfo->memory);
+    const DEVICE_MEMORY_STATE *mem_info = GetDevMemState(pInfo->memory);
 
     // VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in
     // VkExportMemoryAllocateInfoKHR::handleTypes when memory was created.
@@ -3282,7 +3479,7 @@ bool CoreChecks::PreCallValidateGetMemoryAndroidHardwareBufferANDROID(VkDevice d
     // If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo
     // with non-NULL image member, then that image must already be bound to memory.
     if (mem_info->is_dedicated && (VK_NULL_HANDLE != mem_info->dedicated_image)) {
-        auto image_state = GetImageState(mem_info->dedicated_image);
+        const auto image_state = GetImageState(mem_info->dedicated_image);
         if ((nullptr == image_state) || (0 == (image_state->GetBoundMemory().count(pInfo->memory)))) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
                             HandleToUint64(device), "VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883",
@@ -3581,7 +3778,7 @@ static bool ValidateGetPhysicalDeviceImageFormatProperties2ANDROID(const debug_r
     return skip;
 }
 
-bool CoreChecks::ValidateCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info) {
+bool CoreChecks::ValidateCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info) const {
     const VkExternalFormatANDROID *ext_format_android = lvl_find_in_chain<VkExternalFormatANDROID>(create_info->pNext);
     if ((nullptr != ext_format_android) && (0 != ext_format_android->externalFormat)) {
         if (VK_FORMAT_UNDEFINED != create_info->format) {
@@ -3599,15 +3796,15 @@ bool CoreChecks::ValidateCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbc
     return false;
 }
 
-void CoreChecks::RecordCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info,
-                                                           VkSamplerYcbcrConversion ycbcr_conversion) {
+void ValidationStateTracker::RecordCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info,
+                                                                       VkSamplerYcbcrConversion ycbcr_conversion) {
     const VkExternalFormatANDROID *ext_format_android = lvl_find_in_chain<VkExternalFormatANDROID>(create_info->pNext);
     if (ext_format_android && (0 != ext_format_android->externalFormat)) {
         ycbcr_conversion_ahb_fmt_map.emplace(ycbcr_conversion, ext_format_android->externalFormat);
     }
 };
 
-void CoreChecks::RecordDestroySamplerYcbcrConversionANDROID(VkSamplerYcbcrConversion ycbcr_conversion) {
+void ValidationStateTracker::RecordDestroySamplerYcbcrConversionANDROID(VkSamplerYcbcrConversion ycbcr_conversion) {
     ycbcr_conversion_ahb_fmt_map.erase(ycbcr_conversion);
 };
 
@@ -3621,16 +3818,16 @@ static bool ValidateGetPhysicalDeviceImageFormatProperties2ANDROID(const debug_r
     return false;
 }
 
-bool CoreChecks::ValidateCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info) {
+bool CoreChecks::ValidateCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info) const {
     return false;
 }
 
 bool CoreChecks::ValidateGetImageMemoryRequirements2ANDROID(const VkImage image) const { return false; }
 
-void CoreChecks::RecordCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info,
-                                                           VkSamplerYcbcrConversion ycbcr_conversion){};
+void ValidationStateTracker::RecordCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo *create_info,
+                                                                       VkSamplerYcbcrConversion ycbcr_conversion){};
 
-void CoreChecks::RecordDestroySamplerYcbcrConversionANDROID(VkSamplerYcbcrConversion ycbcr_conversion){};
+void ValidationStateTracker::RecordDestroySamplerYcbcrConversionANDROID(VkSamplerYcbcrConversion ycbcr_conversion){};
 
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
@@ -3830,7 +4027,7 @@ void CoreChecks::RetireFence(VkFence fence) {
     if (pFence && pFence->scope == kSyncScopeInternal) {
         if (pFence->signaler.first != VK_NULL_HANDLE) {
             // Fence signaller is a queue -- use this as proof that prior operations on that queue have completed.
-            RetireWorkOnQueue(GetQueueState(pFence->signaler.first), pFence->signaler.second);
+            RetireWorkOnQueue(GetQueueState(pFence->signaler.first), pFence->signaler.second, true);
         } else {
             // Fence signaller is the WSI. We're not tracking what the WSI op actually /was/ in CV yet, but we need to mark
             // the fence as retired.
@@ -3869,7 +4066,7 @@ void CoreChecks::PostCallRecordGetFenceStatus(VkDevice device, VkFence fence, Vk
     RetireFence(fence);
 }
 
-void CoreChecks::RecordGetDeviceQueueState(uint32_t queue_family_index, VkQueue queue) {
+void ValidationStateTracker::RecordGetDeviceQueueState(uint32_t queue_family_index, VkQueue queue) {
     // Add queue to tracking set only if it is new
     auto queue_is_new = queues.emplace(queue);
     if (queue_is_new.second == true) {
@@ -3881,7 +4078,7 @@ void CoreChecks::RecordGetDeviceQueueState(uint32_t queue_family_index, VkQueue
 }
 
 bool CoreChecks::ValidateGetDeviceQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue, const char *valid_qfi_vuid,
-                                        const char *qfi_in_range_vuid) {
+                                        const char *qfi_in_range_vuid) const {
     bool skip = false;
 
     skip |= ValidateDeviceQueueFamily(queueFamilyIndex, "vkGetDeviceQueue", "queueFamilyIndex", valid_qfi_vuid);
@@ -3902,11 +4099,12 @@ bool CoreChecks::PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFa
                                   "VUID-vkGetDeviceQueue-queueIndex-00385");
 }
 
-void CoreChecks::PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) {
+void ValidationStateTracker::PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
+                                                          VkQueue *pQueue) {
     RecordGetDeviceQueueState(queueFamilyIndex, *pQueue);
 }
 
-void CoreChecks::PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
+void ValidationStateTracker::PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
     RecordGetDeviceQueueState(pQueueInfo->queueFamilyIndex, *pQueue);
 }
 
@@ -3918,7 +4116,7 @@ bool CoreChecks::PreCallValidateQueueWaitIdle(VkQueue queue) {
 void CoreChecks::PostCallRecordQueueWaitIdle(VkQueue queue, VkResult result) {
     if (VK_SUCCESS != result) return;
     QUEUE_STATE *queue_state = GetQueueState(queue);
-    RetireWorkOnQueue(queue_state, queue_state->seq + queue_state->submissions.size());
+    RetireWorkOnQueue(queue_state, queue_state->seq + queue_state->submissions.size(), true);
 }
 
 bool CoreChecks::PreCallValidateDeviceWaitIdle(VkDevice device) {
@@ -3932,12 +4130,12 @@ bool CoreChecks::PreCallValidateDeviceWaitIdle(VkDevice device) {
 void CoreChecks::PostCallRecordDeviceWaitIdle(VkDevice device, VkResult result) {
     if (VK_SUCCESS != result) return;
     for (auto &queue : queueMap) {
-        RetireWorkOnQueue(&queue.second, queue.second.seq + queue.second.submissions.size());
+        RetireWorkOnQueue(&queue.second, queue.second.seq + queue.second.submissions.size(), true);
     }
 }
 
 bool CoreChecks::PreCallValidateDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
-    FENCE_STATE *fence_node = GetFenceState(fence);
+    const FENCE_STATE *fence_node = GetFenceState(fence);
     bool skip = false;
     if (fence_node) {
         if (fence_node->scope == kSyncScopeInternal && fence_node->state == FENCE_INFLIGHT) {
@@ -3949,13 +4147,13 @@ bool CoreChecks::PreCallValidateDestroyFence(VkDevice device, VkFence fence, con
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks *pAllocator) {
     if (!fence) return;
     fenceMap.erase(fence);
 }
 
 bool CoreChecks::PreCallValidateDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
-    SEMAPHORE_STATE *sema_node = GetSemaphoreState(semaphore);
+    const SEMAPHORE_STATE *sema_node = GetSemaphoreState(semaphore);
     const VulkanTypedHandle obj_struct(semaphore, kVulkanObjectTypeSemaphore);
     bool skip = false;
     if (sema_node) {
@@ -3964,13 +4162,14 @@ bool CoreChecks::PreCallValidateDestroySemaphore(VkDevice device, VkSemaphore se
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore,
+                                                           const VkAllocationCallbacks *pAllocator) {
     if (!semaphore) return;
     semaphoreMap.erase(semaphore);
 }
 
 bool CoreChecks::PreCallValidateDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
-    EVENT_STATE *event_state = GetEventState(event);
+    const EVENT_STATE *event_state = GetEventState(event);
     const VulkanTypedHandle obj_struct(event, kVulkanObjectTypeEvent);
     bool skip = false;
     if (event_state) {
@@ -3979,7 +4178,7 @@ bool CoreChecks::PreCallValidateDestroyEvent(VkDevice device, VkEvent event, con
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks *pAllocator) {
     if (!event) return;
     EVENT_STATE *event_state = GetEventState(event);
     const VulkanTypedHandle obj_struct(event, kVulkanObjectTypeEvent);
@@ -3989,7 +4188,7 @@ void CoreChecks::PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const
 
 bool CoreChecks::PreCallValidateDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) {
     if (disabled.query_validation) return false;
-    QUERY_POOL_STATE *qp_state = GetQueryPoolState(queryPool);
+    const QUERY_POOL_STATE *qp_state = GetQueryPoolState(queryPool);
     const VulkanTypedHandle obj_struct(queryPool, kVulkanObjectTypeQueryPool);
     bool skip = false;
     if (qp_state) {
@@ -3998,7 +4197,8 @@ bool CoreChecks::PreCallValidateDestroyQueryPool(VkDevice device, VkQueryPool qu
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
+                                                           const VkAllocationCallbacks *pAllocator) {
     if (!queryPool) return;
     QUERY_POOL_STATE *qp_state = GetQueryPoolState(queryPool);
     const VulkanTypedHandle obj_struct(queryPool, kVulkanObjectTypeQueryPool);
@@ -4006,16 +4206,11 @@ void CoreChecks::PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool quer
     queryPoolMap.erase(queryPool);
 }
 
-bool CoreChecks::PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
-                                                    uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride,
-                                                    VkQueryResultFlags flags) {
-    if (disabled.query_validation) return false;
+bool CoreChecks::ValidateGetQueryPoolResultsFlags(VkQueryPool queryPool, VkQueryResultFlags flags) const {
     bool skip = false;
-    skip |= ValidateQueryPoolStride("VUID-vkGetQueryPoolResults-flags-00814", "VUID-vkGetQueryPoolResults-flags-00815", stride,
-                                    "dataSize", dataSize, flags);
-    auto query_pool_state = queryPoolMap.find(queryPool);
-    if (query_pool_state != queryPoolMap.end()) {
-        if ((query_pool_state->second->createInfo.queryType == VK_QUERY_TYPE_TIMESTAMP) && (flags & VK_QUERY_RESULT_PARTIAL_BIT)) {
+    const auto query_pool_state = GetQueryPoolState(queryPool);
+    if (query_pool_state) {
+        if ((query_pool_state->createInfo.queryType == VK_QUERY_TYPE_TIMESTAMP) && (flags & VK_QUERY_RESULT_PARTIAL_BIT)) {
             skip |= log_msg(
                 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, HandleToUint64(queryPool),
                 "VUID-vkGetQueryPoolResults-queryType-00818",
@@ -4023,111 +4218,49 @@ bool CoreChecks::PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool
                 report_data->FormatHandle(queryPool).c_str());
         }
     }
+    return skip;
+}
 
+bool CoreChecks::ValidateGetQueryPoolResultsQueries(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const {
+    bool skip = false;
     QueryObject query_obj{queryPool, 0u};
-    QueryResultType result_type;
-
     for (uint32_t i = 0; i < queryCount; ++i) {
         query_obj.query = firstQuery + i;
-        auto query_data = queryToStateMap.find(query_obj);
-
-        if (query_data != queryToStateMap.end()) {
-            result_type = GetQueryResultType(query_data->second, flags);
-        } else {
-            result_type = QUERYRESULT_UNKNOWN;
-        }
-
-        if (result_type != QUERYRESULT_SOME_DATA) {
+        if (queryToStateMap.count(query_obj) == 0) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT,
                             HandleToUint64(queryPool), kVUID_Core_DrawState_InvalidQuery,
-                            "vkGetQueryPoolResults() on %s and query %" PRIu32 ": %s", report_data->FormatHandle(queryPool).c_str(),
-                            query_obj.query, string_QueryResultType(result_type));
-        }
-    }
-
-    return skip;
-}
-
-// Return true if given ranges intersect, else false
-// Prereq : For both ranges, range->end - range->start > 0. This case should have already resulted
-//  in an error so not checking that here
-// pad_ranges bool indicates a linear and non-linear comparison which requires padding
-// In the case where padding is required, if an alias is encountered then a validation error is reported and skip
-//  may be set by the callback function so caller should merge in skip value if padding case is possible.
-// This check can be skipped by passing skip_checks=true, for call sites outside the validation path.
-bool CoreChecks::RangesIntersect(MEMORY_RANGE const *range1, MEMORY_RANGE const *range2, bool *skip, bool skip_checks) {
-    *skip = false;
-    auto r1_start = range1->start;
-    auto r1_end = range1->end;
-    auto r2_start = range2->start;
-    auto r2_end = range2->end;
-    VkDeviceSize pad_align = 1;
-    if (range1->linear != range2->linear) {
-        pad_align = phys_dev_props.limits.bufferImageGranularity;
-    }
-    if ((r1_end & ~(pad_align - 1)) < (r2_start & ~(pad_align - 1))) return false;
-    if ((r1_start & ~(pad_align - 1)) > (r2_end & ~(pad_align - 1))) return false;
-
-    if (!skip_checks && (range1->linear != range2->linear)) {
-        // In linear vs. non-linear case, warn of aliasing
-        const char *r1_linear_str = range1->linear ? "Linear" : "Non-linear";
-        const char *r2_linear_str = range2->linear ? "linear" : "non-linear";
-        auto obj_type = range1->image ? VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT : VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT;
-        *skip |= log_msg(
-            report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, obj_type, range1->handle, kVUID_Core_MemTrack_InvalidAliasing,
-            "%s %s is aliased with %s %s which may indicate a bug. For further info refer to the Buffer-Image Granularity "
-            "section of the Vulkan specification. "
-            "(https://www.khronos.org/registry/vulkan/specs/1.0-extensions/xhtml/vkspec.html#resources-bufferimagegranularity)",
-            r1_linear_str, report_data->FormatHandle(MemoryRangeTypedHandle(*range1)).c_str(), r2_linear_str,
-            report_data->FormatHandle(MemoryRangeTypedHandle(*range2)).c_str());
-    }
-    // Ranges intersect
-    return true;
-}
-// Simplified RangesIntersect that calls above function to check range1 for intersection with offset & end addresses
-bool CoreChecks::RangesIntersect(MEMORY_RANGE const *range1, VkDeviceSize offset, VkDeviceSize end) {
-    // Create a local MEMORY_RANGE struct to wrap offset/size
-    MEMORY_RANGE range_wrap;
-    // Synch linear with range1 to avoid padding and potential validation error case
-    range_wrap.linear = range1->linear;
-    range_wrap.start = offset;
-    range_wrap.end = end;
-    bool tmp_bool;
-    return RangesIntersect(range1, &range_wrap, &tmp_bool, true);
+                            "vkGetQueryPoolResults() on %s and query %" PRIu32 ": unknown query",
+                            report_data->FormatHandle(queryPool).c_str(), query_obj.query);
+        }
+    }
+    return skip;
 }
 
-bool CoreChecks::ValidateInsertMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize memoryOffset,
-                                           VkMemoryRequirements memRequirements, VulkanObjectType object_type, bool is_linear,
-                                           const char *api_name) {
+bool CoreChecks::PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                                    uint32_t queryCount, size_t dataSize, void *pData, VkDeviceSize stride,
+                                                    VkQueryResultFlags flags) {
+    if (disabled.query_validation) return false;
     bool skip = false;
+    skip |= ValidateQueryPoolStride("VUID-vkGetQueryPoolResults-flags-00814", "VUID-vkGetQueryPoolResults-flags-00815", stride,
+                                    "dataSize", dataSize, flags);
+    skip |= ValidateGetQueryPoolResultsFlags(queryPool, flags);
+    skip |= ValidateGetQueryPoolResultsQueries(queryPool, firstQuery, queryCount);
 
-    MEMORY_RANGE range;
-    range.image = object_type == kVulkanObjectTypeImage;
-    range.handle = handle;
-    range.linear = is_linear;
-    range.memory = mem_info->mem;
-    range.start = memoryOffset;
-    range.size = memRequirements.size;
-    range.end = memoryOffset + memRequirements.size - 1;
-    range.aliases.clear();
+    return skip;
+}
 
-    // Check for aliasing problems.
-    for (auto &obj_range_pair : mem_info->bound_ranges) {
-        auto check_range = &obj_range_pair.second;
-        bool intersection_error = false;
-        if (RangesIntersect(&range, check_range, &intersection_error, false)) {
-            skip |= intersection_error;
-            range.aliases.insert(check_range);
-        }
-    }
+bool CoreChecks::ValidateInsertMemoryRange(const VulkanTypedHandle &typed_handle, const DEVICE_MEMORY_STATE *mem_info,
+                                           VkDeviceSize memoryOffset, const VkMemoryRequirements &memRequirements, bool is_linear,
+                                           const char *api_name) const {
+    bool skip = false;
 
     if (memoryOffset >= mem_info->alloc_info.allocationSize) {
         const char *error_code = nullptr;
-        if (object_type == kVulkanObjectTypeBuffer) {
+        if (typed_handle.type == kVulkanObjectTypeBuffer) {
             error_code = "VUID-vkBindBufferMemory-memoryOffset-01031";
-        } else if (object_type == kVulkanObjectTypeImage) {
+        } else if (typed_handle.type == kVulkanObjectTypeImage) {
             error_code = "VUID-vkBindImageMemory-memoryOffset-01046";
-        } else if (object_type == kVulkanObjectTypeAccelerationStructureNV) {
+        } else if (typed_handle.type == kVulkanObjectTypeAccelerationStructureNV) {
             error_code = "VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-02451";
         } else {
             // Unsupported object type
@@ -4138,9 +4271,8 @@ bool CoreChecks::ValidateInsertMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE
                        HandleToUint64(mem_info->mem), error_code,
                        "In %s, attempting to bind %s to %s, memoryOffset=0x%" PRIxLEAST64
                        " must be less than the memory allocation size 0x%" PRIxLEAST64 ".",
-                       api_name, report_data->FormatHandle(mem_info->mem).c_str(),
-                       report_data->FormatHandle(MemoryRangeTypedHandle(range)).c_str(), memoryOffset,
-                       mem_info->alloc_info.allocationSize);
+                       api_name, report_data->FormatHandle(mem_info->mem).c_str(), report_data->FormatHandle(typed_handle).c_str(),
+                       memoryOffset, mem_info->alloc_info.allocationSize);
     }
 
     return skip;
@@ -4153,89 +4285,53 @@ bool CoreChecks::ValidateInsertMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE
 // Return true if an error is flagged and the user callback returns "true", otherwise false
 // is_image indicates an image object, otherwise handle is for a buffer
 // is_linear indicates a buffer or linear image
-void CoreChecks::InsertMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize memoryOffset,
-                                   VkMemoryRequirements memRequirements, VulkanObjectType object_type, bool is_linear) {
-    MEMORY_RANGE range;
-
-    range.image = object_type == kVulkanObjectTypeImage;
-    range.handle = handle;
-    range.linear = is_linear;
-    range.memory = mem_info->mem;
-    range.start = memoryOffset;
-    range.size = memRequirements.size;
-    range.end = memoryOffset + memRequirements.size - 1;
-    range.aliases.clear();
-    // Update Memory aliasing
-    // Save aliased ranges so we can copy into final map entry below. Can't do it in loop b/c we don't yet have final ptr. If we
-    // inserted into map before loop to get the final ptr, then we may enter loop when not needed & we check range against itself
-    std::unordered_set<MEMORY_RANGE *> tmp_alias_ranges;
-    for (auto &obj_range_pair : mem_info->bound_ranges) {
-        auto check_range = &obj_range_pair.second;
-        bool intersection_error = false;
-        if (RangesIntersect(&range, check_range, &intersection_error, true)) {
-            range.aliases.insert(check_range);
-            tmp_alias_ranges.insert(check_range);
-        }
-    }
-    mem_info->bound_ranges[handle] = std::move(range);
-    for (auto tmp_range : tmp_alias_ranges) {
-        tmp_range->aliases.insert(&mem_info->bound_ranges[handle]);
-    }
-
-    if (object_type == kVulkanObjectTypeImage) {
-        mem_info->bound_images.insert(handle);
-    } else if (object_type == kVulkanObjectTypeBuffer) {
-        mem_info->bound_buffers.insert(handle);
-    } else if (object_type == kVulkanObjectTypeAccelerationStructureNV) {
-        mem_info->bound_acceleration_structures.insert(handle);
+void ValidationStateTracker::InsertMemoryRange(const VulkanTypedHandle &typed_handle, DEVICE_MEMORY_STATE *mem_info,
+                                               VkDeviceSize memoryOffset, VkMemoryRequirements memRequirements, bool is_linear) {
+    if (typed_handle.type == kVulkanObjectTypeImage) {
+        mem_info->bound_images.insert(typed_handle.handle);
+    } else if (typed_handle.type == kVulkanObjectTypeBuffer) {
+        mem_info->bound_buffers.insert(typed_handle.handle);
+    } else if (typed_handle.type == kVulkanObjectTypeAccelerationStructureNV) {
+        mem_info->bound_acceleration_structures.insert(typed_handle.handle);
     } else {
         // Unsupported object type
         assert(false);
     }
 }
 
-bool CoreChecks::ValidateInsertImageMemoryRange(VkImage image, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
-                                                VkMemoryRequirements mem_reqs, bool is_linear, const char *api_name) {
-    return ValidateInsertMemoryRange(HandleToUint64(image), mem_info, mem_offset, mem_reqs, kVulkanObjectTypeImage, is_linear,
+bool CoreChecks::ValidateInsertImageMemoryRange(VkImage image, const DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
+                                                const VkMemoryRequirements &mem_reqs, bool is_linear, const char *api_name) const {
+    return ValidateInsertMemoryRange(VulkanTypedHandle(image, kVulkanObjectTypeImage), mem_info, mem_offset, mem_reqs, is_linear,
                                      api_name);
 }
-void CoreChecks::InsertImageMemoryRange(VkImage image, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
-                                        VkMemoryRequirements mem_reqs, bool is_linear) {
-    InsertMemoryRange(HandleToUint64(image), mem_info, mem_offset, mem_reqs, kVulkanObjectTypeImage, is_linear);
+void ValidationStateTracker::InsertImageMemoryRange(VkImage image, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
+                                                    VkMemoryRequirements mem_reqs, bool is_linear) {
+    InsertMemoryRange(VulkanTypedHandle(image, kVulkanObjectTypeImage), mem_info, mem_offset, mem_reqs, is_linear);
 }
 
-bool CoreChecks::ValidateInsertBufferMemoryRange(VkBuffer buffer, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
-                                                 VkMemoryRequirements mem_reqs, const char *api_name) {
-    return ValidateInsertMemoryRange(HandleToUint64(buffer), mem_info, mem_offset, mem_reqs, kVulkanObjectTypeBuffer, true,
+bool CoreChecks::ValidateInsertBufferMemoryRange(VkBuffer buffer, const DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
+                                                 const VkMemoryRequirements &mem_reqs, const char *api_name) const {
+    return ValidateInsertMemoryRange(VulkanTypedHandle(buffer, kVulkanObjectTypeBuffer), mem_info, mem_offset, mem_reqs, true,
                                      api_name);
 }
-void CoreChecks::InsertBufferMemoryRange(VkBuffer buffer, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
-                                         VkMemoryRequirements mem_reqs) {
-    InsertMemoryRange(HandleToUint64(buffer), mem_info, mem_offset, mem_reqs, kVulkanObjectTypeBuffer, true);
+void ValidationStateTracker::InsertBufferMemoryRange(VkBuffer buffer, DEVICE_MEMORY_STATE *mem_info, VkDeviceSize mem_offset,
+                                                     const VkMemoryRequirements &mem_reqs) {
+    InsertMemoryRange(VulkanTypedHandle(buffer, kVulkanObjectTypeBuffer), mem_info, mem_offset, mem_reqs, true);
 }
 
-bool CoreChecks::ValidateInsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, DEVICE_MEMORY_STATE *mem_info,
-                                                                VkDeviceSize mem_offset, VkMemoryRequirements mem_reqs,
-                                                                const char *api_name) {
-    return ValidateInsertMemoryRange(HandleToUint64(as), mem_info, mem_offset, mem_reqs, kVulkanObjectTypeAccelerationStructureNV,
-                                     true, api_name);
+bool CoreChecks::ValidateInsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, const DEVICE_MEMORY_STATE *mem_info,
+                                                                VkDeviceSize mem_offset, const VkMemoryRequirements &mem_reqs,
+                                                                const char *api_name) const {
+    return ValidateInsertMemoryRange(VulkanTypedHandle(as, kVulkanObjectTypeAccelerationStructureNV), mem_info, mem_offset,
+                                     mem_reqs, true, api_name);
 }
-void CoreChecks::InsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, DEVICE_MEMORY_STATE *mem_info,
-                                                        VkDeviceSize mem_offset, VkMemoryRequirements mem_reqs) {
-    InsertMemoryRange(HandleToUint64(as), mem_info, mem_offset, mem_reqs, kVulkanObjectTypeAccelerationStructureNV, true);
+void ValidationStateTracker::InsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, DEVICE_MEMORY_STATE *mem_info,
+                                                                    VkDeviceSize mem_offset, const VkMemoryRequirements &mem_reqs) {
+    InsertMemoryRange(VulkanTypedHandle(as, kVulkanObjectTypeAccelerationStructureNV), mem_info, mem_offset, mem_reqs, true);
 }
 
-// Remove MEMORY_RANGE struct for give handle from bound_ranges of mem_info
-//  is_image indicates if handle is for image or buffer
-//  This function will also remove the handle-to-index mapping from the appropriate
-//  map and clean up any aliases for range being removed.
+// This function will remove the handle-to-index mapping from the appropriate map.
 static void RemoveMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE *mem_info, VulkanObjectType object_type) {
-    auto erase_range = &mem_info->bound_ranges[handle];
-    for (auto alias_range : erase_range->aliases) {
-        alias_range->aliases.erase(erase_range);
-    }
-    erase_range->aliases.clear();
-    mem_info->bound_ranges.erase(handle);
     if (object_type == kVulkanObjectTypeImage) {
         mem_info->bound_images.erase(handle);
     } else if (object_type == kVulkanObjectTypeBuffer) {
@@ -4261,7 +4357,7 @@ void ValidationStateTracker::RemoveAccelerationStructureMemoryRange(uint64_t han
 }
 
 bool CoreChecks::ValidateMemoryTypes(const DEVICE_MEMORY_STATE *mem_info, const uint32_t memory_type_bits, const char *funcName,
-                                     const char *msgCode) {
+                                     const char *msgCode) const {
     bool skip = false;
     if (((1 << mem_info->alloc_info.memoryTypeIndex) & memory_type_bits) == 0) {
         skip = log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
@@ -4274,8 +4370,9 @@ bool CoreChecks::ValidateMemoryTypes(const DEVICE_MEMORY_STATE *mem_info, const
     return skip;
 }
 
-bool CoreChecks::ValidateBindBufferMemory(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset, const char *api_name) {
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
+bool CoreChecks::ValidateBindBufferMemory(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset,
+                                          const char *api_name) const {
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
 
     bool skip = false;
     if (buffer_state) {
@@ -4288,11 +4385,10 @@ bool CoreChecks::ValidateBindBufferMemory(VkBuffer buffer, VkDeviceMemory mem, V
             // BindBufferMemory, but it's implied in that memory being bound must conform with VkMemoryRequirements from
             // vkGetBufferMemoryRequirements()
             skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, buffer_handle,
-                            kVUID_Core_DrawState_InvalidBuffer,
+                            kVUID_Core_BindBuffer_NoMemReqQuery,
                             "%s: Binding memory to %s but vkGetBufferMemoryRequirements() has not been called on that buffer.",
                             api_name, report_data->FormatHandle(buffer).c_str());
-            // Make the call for them so we can verify the state
-            DispatchGetBufferMemoryRequirements(device, buffer, &buffer_state->requirements);
+            // In the following we'll use the information we got in CreateBuffer
         }
 
         // Validate bound memory range information
@@ -4349,7 +4445,7 @@ bool CoreChecks::PreCallValidateBindBufferMemory(VkDevice device, VkBuffer buffe
     return ValidateBindBufferMemory(buffer, mem, memoryOffset, api_name);
 }
 
-void CoreChecks::UpdateBindBufferMemoryState(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) {
+void ValidationStateTracker::UpdateBindBufferMemoryState(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset) {
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
     if (buffer_state) {
         // Track bound memory range information
@@ -4362,8 +4458,8 @@ void CoreChecks::UpdateBindBufferMemoryState(VkBuffer buffer, VkDeviceMemory mem
     }
 }
 
-void CoreChecks::PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset,
-                                                VkResult result) {
+void ValidationStateTracker::PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
+                                                            VkDeviceSize memoryOffset, VkResult result) {
     if (VK_SUCCESS != result) return;
     UpdateBindBufferMemoryState(buffer, mem, memoryOffset);
 }
@@ -4392,21 +4488,21 @@ bool CoreChecks::PreCallValidateBindBufferMemory2KHR(VkDevice device, uint32_t b
     return skip;
 }
 
-void CoreChecks::PostCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
-                                                 const VkBindBufferMemoryInfoKHR *pBindInfos, VkResult result) {
+void ValidationStateTracker::PostCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount,
+                                                             const VkBindBufferMemoryInfoKHR *pBindInfos, VkResult result) {
     for (uint32_t i = 0; i < bindInfoCount; i++) {
         UpdateBindBufferMemoryState(pBindInfos[i].buffer, pBindInfos[i].memory, pBindInfos[i].memoryOffset);
     }
 }
 
-void CoreChecks::PostCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
-                                                    const VkBindBufferMemoryInfoKHR *pBindInfos, VkResult result) {
+void ValidationStateTracker::PostCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                                                const VkBindBufferMemoryInfoKHR *pBindInfos, VkResult result) {
     for (uint32_t i = 0; i < bindInfoCount; i++) {
         UpdateBindBufferMemoryState(pBindInfos[i].buffer, pBindInfos[i].memory, pBindInfos[i].memoryOffset);
     }
 }
 
-void CoreChecks::RecordGetBufferMemoryRequirementsState(VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) {
+void ValidationStateTracker::RecordGetBufferMemoryRequirementsState(VkBuffer buffer, VkMemoryRequirements *pMemoryRequirements) {
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
     if (buffer_state) {
         buffer_state->requirements = *pMemoryRequirements;
@@ -4414,22 +4510,24 @@ void CoreChecks::RecordGetBufferMemoryRequirementsState(VkBuffer buffer, VkMemor
     }
 }
 
-void CoreChecks::PostCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
-                                                           VkMemoryRequirements *pMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
+                                                                       VkMemoryRequirements *pMemoryRequirements) {
     RecordGetBufferMemoryRequirementsState(buffer, pMemoryRequirements);
 }
 
-void CoreChecks::PostCallRecordGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR *pInfo,
-                                                            VkMemoryRequirements2KHR *pMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetBufferMemoryRequirements2(VkDevice device,
+                                                                        const VkBufferMemoryRequirementsInfo2KHR *pInfo,
+                                                                        VkMemoryRequirements2KHR *pMemoryRequirements) {
     RecordGetBufferMemoryRequirementsState(pInfo->buffer, &pMemoryRequirements->memoryRequirements);
 }
 
-void CoreChecks::PostCallRecordGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR *pInfo,
-                                                               VkMemoryRequirements2KHR *pMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetBufferMemoryRequirements2KHR(VkDevice device,
+                                                                           const VkBufferMemoryRequirementsInfo2KHR *pInfo,
+                                                                           VkMemoryRequirements2KHR *pMemoryRequirements) {
     RecordGetBufferMemoryRequirementsState(pInfo->buffer, &pMemoryRequirements->memoryRequirements);
 }
 
-bool CoreChecks::ValidateGetImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2 *pInfo) {
+bool CoreChecks::ValidateGetImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2 *pInfo) const {
     bool skip = false;
     if (device_extensions.vk_android_external_memory_android_hardware_buffer) {
         skip |= ValidateGetImageMemoryRequirements2ANDROID(pInfo->image);
@@ -4447,7 +4545,7 @@ bool CoreChecks::PreCallValidateGetImageMemoryRequirements2KHR(VkDevice device,
     return ValidateGetImageMemoryRequirements2(pInfo);
 }
 
-void CoreChecks::RecordGetImageMemoryRequiementsState(VkImage image, VkMemoryRequirements *pMemoryRequirements) {
+void ValidationStateTracker::RecordGetImageMemoryRequiementsState(VkImage image, VkMemoryRequirements *pMemoryRequirements) {
     IMAGE_STATE *image_state = GetImageState(image);
     if (image_state) {
         image_state->requirements = *pMemoryRequirements;
@@ -4455,18 +4553,19 @@ void CoreChecks::RecordGetImageMemoryRequiementsState(VkImage image, VkMemoryReq
     }
 }
 
-void CoreChecks::PostCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image,
-                                                          VkMemoryRequirements *pMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image,
+                                                                      VkMemoryRequirements *pMemoryRequirements) {
     RecordGetImageMemoryRequiementsState(image, pMemoryRequirements);
 }
 
-void CoreChecks::PostCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo,
-                                                           VkMemoryRequirements2 *pMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo,
+                                                                       VkMemoryRequirements2 *pMemoryRequirements) {
     RecordGetImageMemoryRequiementsState(pInfo->image, &pMemoryRequirements->memoryRequirements);
 }
 
-void CoreChecks::PostCallRecordGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo,
-                                                              VkMemoryRequirements2 *pMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetImageMemoryRequirements2KHR(VkDevice device,
+                                                                          const VkImageMemoryRequirementsInfo2 *pInfo,
+                                                                          VkMemoryRequirements2 *pMemoryRequirements) {
     RecordGetImageMemoryRequiementsState(pInfo->image, &pMemoryRequirements->memoryRequirements);
 }
 
@@ -4478,9 +4577,9 @@ static void RecordGetImageSparseMemoryRequirementsState(IMAGE_STATE *image_state
     }
 }
 
-void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image,
-                                                                uint32_t *pSparseMemoryRequirementCount,
-                                                                VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetImageSparseMemoryRequirements(
+    VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
     auto image_state = GetImageState(image);
     image_state->get_sparse_reqs_called = true;
     if (!pSparseMemoryRequirements) return;
@@ -4489,10 +4588,9 @@ void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements(VkDevice device,
     }
 }
 
-void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device,
-                                                                 const VkImageSparseMemoryRequirementsInfo2KHR *pInfo,
-                                                                 uint32_t *pSparseMemoryRequirementCount,
-                                                                 VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) {
+void ValidationStateTracker::PostCallRecordGetImageSparseMemoryRequirements2(
+    VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, uint32_t *pSparseMemoryRequirementCount,
+    VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) {
     auto image_state = GetImageState(pInfo->image);
     image_state->get_sparse_reqs_called = true;
     if (!pSparseMemoryRequirements) return;
@@ -4502,7 +4600,7 @@ void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device
     }
 }
 
-void CoreChecks::PostCallRecordGetImageSparseMemoryRequirements2KHR(
+void ValidationStateTracker::PostCallRecordGetImageSparseMemoryRequirements2KHR(
     VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR *pInfo, uint32_t *pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements2KHR *pSparseMemoryRequirements) {
     auto image_state = GetImageState(pInfo->image);
@@ -4571,7 +4669,7 @@ void ValidationStateTracker::PreCallRecordDestroyPipelineLayout(VkDevice device,
 }
 
 bool CoreChecks::PreCallValidateDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
-    SAMPLER_STATE *sampler_state = GetSamplerState(sampler);
+    const SAMPLER_STATE *sampler_state = GetSamplerState(sampler);
     const VulkanTypedHandle obj_struct(sampler, kVulkanObjectTypeSampler);
     bool skip = false;
     if (sampler_state) {
@@ -4580,7 +4678,8 @@ bool CoreChecks::PreCallValidateDestroySampler(VkDevice device, VkSampler sample
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker ::PreCallRecordDestroySampler(VkDevice device, VkSampler sampler,
+                                                          const VkAllocationCallbacks *pAllocator) {
     if (!sampler) return;
     SAMPLER_STATE *sampler_state = GetSamplerState(sampler);
     const VulkanTypedHandle obj_struct(sampler, kVulkanObjectTypeSampler);
@@ -4697,9 +4796,9 @@ bool CoreChecks::PreCallValidateCreateCommandPool(VkDevice device, const VkComma
                                      "VUID-vkCreateCommandPool-queueFamilyIndex-01937");
 }
 
-void CoreChecks::PostCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
-                                                 const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool,
-                                                 VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
+                                                             const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool,
+                                                             VkResult result) {
     if (VK_SUCCESS != result) return;
     std::unique_ptr<COMMAND_POOL_STATE> cmd_pool_state(new COMMAND_POOL_STATE{});
     cmd_pool_state->createFlags = pCreateInfo->flags;
@@ -4722,8 +4821,9 @@ bool CoreChecks::PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPo
     return skip;
 }
 
-void CoreChecks::PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
-                                               const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool, VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
+                                                           const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool,
+                                                           VkResult result) {
     if (VK_SUCCESS != result) return;
     std::unique_ptr<QUERY_POOL_STATE> query_pool_state(new QUERY_POOL_STATE{});
     query_pool_state->createInfo = *pCreateInfo;
@@ -4738,7 +4838,7 @@ void CoreChecks::PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoo
 
 bool CoreChecks::PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
                                                    const VkAllocationCallbacks *pAllocator) {
-    COMMAND_POOL_STATE *cp_state = GetCommandPoolState(commandPool);
+    const COMMAND_POOL_STATE *cp_state = GetCommandPoolState(commandPool);
     bool skip = false;
     if (cp_state) {
         // Verify that command buffers in pool are complete (not in-flight)
@@ -4747,8 +4847,8 @@ bool CoreChecks::PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPoo
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
-                                                 const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
+                                                             const VkAllocationCallbacks *pAllocator) {
     if (!commandPool) return;
     COMMAND_POOL_STATE *cp_state = GetCommandPoolState(commandPool);
     // Remove cmdpool from cmdpoolmap, after freeing layer data for the command buffers
@@ -4822,7 +4922,7 @@ void ValidationStateTracker::InvalidateCommandBuffers(std::unordered_set<CMD_BUF
 
 bool CoreChecks::PreCallValidateDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
                                                    const VkAllocationCallbacks *pAllocator) {
-    FRAMEBUFFER_STATE *framebuffer_state = GetFramebufferState(framebuffer);
+    const FRAMEBUFFER_STATE *framebuffer_state = GetFramebufferState(framebuffer);
     const VulkanTypedHandle obj_struct(framebuffer, kVulkanObjectTypeFramebuffer);
     bool skip = false;
     if (framebuffer_state) {
@@ -4832,8 +4932,8 @@ bool CoreChecks::PreCallValidateDestroyFramebuffer(VkDevice device, VkFramebuffe
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
-                                                 const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
+                                                             const VkAllocationCallbacks *pAllocator) {
     if (!framebuffer) return;
     FRAMEBUFFER_STATE *framebuffer_state = GetFramebufferState(framebuffer);
     const VulkanTypedHandle obj_struct(framebuffer, kVulkanObjectTypeFramebuffer);
@@ -4843,7 +4943,7 @@ void CoreChecks::PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer
 
 bool CoreChecks::PreCallValidateDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
                                                   const VkAllocationCallbacks *pAllocator) {
-    RENDER_PASS_STATE *rp_state = GetRenderPassState(renderPass);
+    const RENDER_PASS_STATE *rp_state = GetRenderPassState(renderPass);
     const VulkanTypedHandle obj_struct(renderPass, kVulkanObjectTypeRenderPass);
     bool skip = false;
     if (rp_state) {
@@ -4852,7 +4952,8 @@ bool CoreChecks::PreCallValidateDestroyRenderPass(VkDevice device, VkRenderPass
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
+                                                            const VkAllocationCallbacks *pAllocator) {
     if (!renderPass) return;
     RENDER_PASS_STATE *rp_state = GetRenderPassState(renderPass);
     const VulkanTypedHandle obj_struct(renderPass, kVulkanObjectTypeRenderPass);
@@ -4879,8 +4980,8 @@ VkResult CoreChecks::GetPDImageFormatProperties2(const VkPhysicalDeviceImageForm
     return DispatchGetPhysicalDeviceImageFormatProperties2(physical_device, phys_dev_image_fmt_info, pImageFormatProperties);
 }
 
-void CoreChecks::PostCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
-                                           const VkAllocationCallbacks *pAllocator, VkFence *pFence, VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
+                                                       const VkAllocationCallbacks *pAllocator, VkFence *pFence, VkResult result) {
     if (VK_SUCCESS != result) return;
     std::unique_ptr<FENCE_STATE> fence_state(new FENCE_STATE{});
     fence_state->fence = *pFence;
@@ -5069,7 +5170,6 @@ bool ValidationStateTracker::PreCallValidateCreateComputePipelines(VkDevice devi
                                                                    const VkComputePipelineCreateInfo *pCreateInfos,
                                                                    const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines,
                                                                    void *ccpl_state_data) {
-    bool skip = false;
     auto *ccpl_state = reinterpret_cast<create_compute_pipeline_api_state *>(ccpl_state_data);
     ccpl_state->pCreateInfos = pCreateInfos;  // GPU validation can alter this, so we have to set a default value for the Chassis
     ccpl_state->pipe_state.reserve(count);
@@ -5079,7 +5179,7 @@ bool ValidationStateTracker::PreCallValidateCreateComputePipelines(VkDevice devi
         ccpl_state->pipe_state.back()->initComputePipeline(this, &pCreateInfos[i]);
         ccpl_state->pipe_state.back()->pipeline_layout = *GetPipelineLayout(pCreateInfos[i].layout);
     }
-    return skip;
+    return false;
 }
 
 bool CoreChecks::PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
@@ -5145,18 +5245,14 @@ bool ValidationStateTracker::PreCallValidateCreateRayTracingPipelinesNV(VkDevice
                                                                         uint32_t count,
                                                                         const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
                                                                         const VkAllocationCallbacks *pAllocator,
-                                                                        VkPipeline *pPipelines, void *pipe_state_data) {
-    // The order of operations here is a little convoluted but gets the job done
-    //  1. Pipeline create state is first shadowed into PIPELINE_STATE struct
-    //  2. Create state is then validated (which uses flags setup during shadowing)
-    //  3. If everything looks good, we'll then create the pipeline and add NODE to pipelineMap
-    vector<std::unique_ptr<PIPELINE_STATE>> *pipe_state =
-        reinterpret_cast<vector<std::unique_ptr<PIPELINE_STATE>> *>(pipe_state_data);
-    pipe_state->reserve(count);
+                                                                        VkPipeline *pPipelines, void *crtpl_state_data) {
+    auto *crtpl_state = reinterpret_cast<create_ray_tracing_pipeline_api_state *>(crtpl_state_data);
+    crtpl_state->pipe_state.reserve(count);
     for (uint32_t i = 0; i < count; i++) {
-        pipe_state->push_back(std::unique_ptr<PIPELINE_STATE>(new PIPELINE_STATE));
-        (*pipe_state)[i]->initRayTracingPipelineNV(this, &pCreateInfos[i]);
-        (*pipe_state)[i]->pipeline_layout = *GetPipelineLayout(pCreateInfos[i].layout);
+        // Create and initialize internal tracking data structure
+        crtpl_state->pipe_state.push_back(unique_ptr<PIPELINE_STATE>(new PIPELINE_STATE));
+        crtpl_state->pipe_state.back()->initRayTracingPipelineNV(this, &pCreateInfos[i]);
+        crtpl_state->pipe_state.back()->pipeline_layout = *GetPipelineLayout(pCreateInfos[i].layout);
     }
     return false;
 }
@@ -5164,35 +5260,138 @@ bool ValidationStateTracker::PreCallValidateCreateRayTracingPipelinesNV(VkDevice
 bool CoreChecks::PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
                                                             const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
                                                             const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines,
-                                                            void *pipe_state_data) {
+                                                            void *crtpl_state_data) {
     bool skip = StateTracker::PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, count, pCreateInfos, pAllocator,
-                                                                         pPipelines, pipe_state_data);
-    vector<std::unique_ptr<PIPELINE_STATE>> *pipe_state =
-        reinterpret_cast<vector<std::unique_ptr<PIPELINE_STATE>> *>(pipe_state_data);
+                                                                         pPipelines, crtpl_state_data);
+
+    auto *crtpl_state = reinterpret_cast<create_ray_tracing_pipeline_api_state *>(crtpl_state_data);
     for (uint32_t i = 0; i < count; i++) {
-        skip |= ValidateRayTracingPipelineNV((*pipe_state)[i].get());
+        skip |= ValidateRayTracingPipelineNV(crtpl_state->pipe_state[i].get());
     }
-
     return skip;
 }
 
+void CoreChecks::PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                                          const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
+                                                          const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines,
+                                                          void *crtpl_state_data) {
+    // GPU Validation may replace instrumented shaders with non-instrumented ones, so allow it to modify the createinfos.
+    if (enabled.gpu_validation) {
+        auto *crtpl_state = reinterpret_cast<create_ray_tracing_pipeline_api_state *>(crtpl_state_data);
+        crtpl_state->gpu_create_infos = GpuPreCallRecordCreateRayTracingPipelinesNV(pipelineCache, count, pCreateInfos, pAllocator,
+                                                                                    pPipelines, crtpl_state->pipe_state);
+        crtpl_state->pCreateInfos = reinterpret_cast<VkRayTracingPipelineCreateInfoNV *>(crtpl_state->gpu_create_infos.data());
+    }
+}
+
 void ValidationStateTracker::PostCallRecordCreateRayTracingPipelinesNV(
     VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
-    const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, VkResult result, void *pipe_state_data) {
-    vector<std::unique_ptr<PIPELINE_STATE>> *pipe_state =
-        reinterpret_cast<vector<std::unique_ptr<PIPELINE_STATE>> *>(pipe_state_data);
+    const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, VkResult result, void *crtpl_state_data) {
+    auto *crtpl_state = reinterpret_cast<create_ray_tracing_pipeline_api_state *>(crtpl_state_data);
     // This API may create pipelines regardless of the return value
     for (uint32_t i = 0; i < count; i++) {
         if (pPipelines[i] != VK_NULL_HANDLE) {
-            (*pipe_state)[i]->pipeline = pPipelines[i];
-            pipelineMap[pPipelines[i]] = std::move((*pipe_state)[i]);
+            (crtpl_state->pipe_state)[i]->pipeline = pPipelines[i];
+            pipelineMap[pPipelines[i]] = std::move((crtpl_state->pipe_state)[i]);
         }
     }
-    pipe_state->clear();
+    crtpl_state->pipe_state.clear();
 }
 
-void CoreChecks::PostCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
-                                             const VkAllocationCallbacks *pAllocator, VkSampler *pSampler, VkResult result) {
+void CoreChecks::PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                                           const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
+                                                           const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines,
+                                                           VkResult result, void *crtpl_state_data) {
+    StateTracker::PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines,
+                                                            result, crtpl_state_data);
+    // GPU val needs clean up regardless of result
+    if (enabled.gpu_validation) {
+        auto *crtpl_state = reinterpret_cast<create_ray_tracing_pipeline_api_state *>(crtpl_state_data);
+        GpuPostCallRecordCreateRayTracingPipelinesNV(count, pCreateInfos, pAllocator, pPipelines);
+        crtpl_state->gpu_create_infos.clear();
+    }
+}
+
+bool CoreChecks::PreCallValidateGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR *pPipelineInfo,
+                                                                   uint32_t *pExecutableCount,
+                                                                   VkPipelineExecutablePropertiesKHR *pProperties) {
+    bool skip = false;
+
+    if (!enabled_features.pipeline_exe_props_features.pipelineExecutableInfo) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
+                        "VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableProperties-03270",
+                        "vkGetPipelineExecutablePropertiesKHR called when pipelineExecutableInfo feature is not enabled.");
+    }
+
+    return skip;
+}
+
+bool CoreChecks::ValidatePipelineExecutableInfo(VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo) const {
+    bool skip = false;
+
+    if (!enabled_features.pipeline_exe_props_features.pipelineExecutableInfo) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
+                        "VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272",
+                        "vkGetPipelineExecutableStatisticsKHR called when pipelineExecutableInfo feature is not enabled.");
+    }
+
+    VkPipelineInfoKHR pi = {};
+    pi.sType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
+    pi.pipeline = pExecutableInfo->pipeline;
+
+    // We could probably cache this instead of fetching it every time
+    uint32_t executableCount = 0;
+    DispatchGetPipelineExecutablePropertiesKHR(device, &pi, &executableCount, NULL);
+
+    if (pExecutableInfo->executableIndex >= executableCount) {
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+                    HandleToUint64(pExecutableInfo->pipeline), "VUID-VkPipelineExecutableInfoKHR-executableIndex-03275",
+                    "VkPipelineExecutableInfo::executableIndex (%1u) must be less than the number of executables associated with "
+                    "the pipeline (%1u) as returned by vkGetPipelineExecutablePropertiessKHR",
+                    pExecutableInfo->executableIndex, executableCount);
+    }
+
+    return skip;
+}
+
+bool CoreChecks::PreCallValidateGetPipelineExecutableStatisticsKHR(VkDevice device,
+                                                                   const VkPipelineExecutableInfoKHR *pExecutableInfo,
+                                                                   uint32_t *pStatisticCount,
+                                                                   VkPipelineExecutableStatisticKHR *pStatistics) {
+    bool skip = ValidatePipelineExecutableInfo(device, pExecutableInfo);
+
+    const PIPELINE_STATE *pipeline_state = GetPipelineState(pExecutableInfo->pipeline);
+    if (!(pipeline_state->getPipelineCreateFlags() & VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR)) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+                        HandleToUint64(pExecutableInfo->pipeline), "VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274",
+                        "vkGetPipelineExecutableStatisticsKHR called on a pipeline created without the "
+                        "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR flag set");
+    }
+
+    return skip;
+}
+
+bool CoreChecks::PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice device, const VkPipelineExecutableInfoKHR *pExecutableInfo, uint32_t *pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR *pStatistics) {
+    bool skip = ValidatePipelineExecutableInfo(device, pExecutableInfo);
+
+    const PIPELINE_STATE *pipeline_state = GetPipelineState(pExecutableInfo->pipeline);
+    if (!(pipeline_state->getPipelineCreateFlags() & VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR)) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
+                        HandleToUint64(pExecutableInfo->pipeline),
+                        "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278",
+                        "vkGetPipelineExecutableInternalRepresentationsKHR called on a pipeline created without the "
+                        "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR flag set");
+    }
+
+    return skip;
+}
+
+void ValidationStateTracker::PostCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
+                                                         const VkAllocationCallbacks *pAllocator, VkSampler *pSampler,
+                                                         VkResult result) {
     samplerMap[*pSampler] = unique_ptr<SAMPLER_STATE>(new SAMPLER_STATE(pSampler, pCreateInfo));
 }
 
@@ -5202,7 +5401,7 @@ bool CoreChecks::PreCallValidateCreateDescriptorSetLayout(VkDevice device, const
     return cvdescriptorset::ValidateDescriptorSetLayoutCreateInfo(
         report_data, pCreateInfo, device_extensions.vk_khr_push_descriptor, phys_dev_ext_props.max_push_descriptors,
         device_extensions.vk_ext_descriptor_indexing, &enabled_features.descriptor_indexing, &enabled_features.inline_uniform_block,
-        &phys_dev_ext_props.inline_uniform_block_props);
+        &phys_dev_ext_props.inline_uniform_block_props, &device_extensions);
 }
 
 void ValidationStateTracker::PostCallRecordCreateDescriptorSetLayout(VkDevice device,
@@ -6063,8 +6262,8 @@ void ValidationStateTracker::PreCallRecordUpdateDescriptorSets(VkDevice device,
                                                  pDescriptorCopies);
 }
 
-void CoreChecks::PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo,
-                                                      VkCommandBuffer *pCommandBuffer, VkResult result) {
+void ValidationStateTracker::PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pCreateInfo,
+                                                                  VkCommandBuffer *pCommandBuffer, VkResult result) {
     if (VK_SUCCESS != result) return;
     auto pPool = GetCommandPoolState(pCreateInfo->commandPool);
     if (pPool) {
@@ -6237,6 +6436,7 @@ bool CoreChecks::PreCallValidateEndCommandBuffer(VkCommandBuffer commandBuffer)
         // https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/165
         skip |= InsideRenderPass(cb_state, "vkEndCommandBuffer()", "VUID-vkEndCommandBuffer-commandBuffer-00060");
     }
+
     skip |= ValidateCmd(cb_state, CMD_ENDCOMMANDBUFFER, "vkEndCommandBuffer()");
     for (auto query : cb_state->activeQueries) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -6434,7 +6634,7 @@ void ValidationStateTracker::PreCallRecordCmdSetExclusiveScissorNV(VkCommandBuff
 
 bool CoreChecks::PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
                                                           VkImageLayout imageLayout) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     bool skip = ValidateCmdQueueFlags(cb_state, "vkCmdBindShadingRateImageNV()", VK_QUEUE_GRAPHICS_BIT,
                                       "VUID-vkCmdBindShadingRateImageNV-commandBuffer-cmdpool");
@@ -6448,7 +6648,7 @@ bool CoreChecks::PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer comman
     }
 
     if (imageView != VK_NULL_HANDLE) {
-        auto view_state = GetImageViewState(imageView);
+        const auto view_state = GetImageViewState(imageView);
         auto &ivci = view_state->create_info;
 
         if (!view_state || (ivci.viewType != VK_IMAGE_VIEW_TYPE_2D && ivci.viewType != VK_IMAGE_VIEW_TYPE_2D_ARRAY)) {
@@ -6474,7 +6674,7 @@ bool CoreChecks::PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer comman
         }
 
         if (view_state) {
-            auto image_state = GetImageState(view_state->create_info.image);
+            const auto image_state = GetImageState(view_state->create_info.image);
             bool hit_error = false;
 
             // XXX TODO: While the VUID says "each subresource", only the base mip level is
@@ -6494,8 +6694,8 @@ bool CoreChecks::PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer comman
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
-                                                        VkImageLayout imageLayout) {
+void ValidationStateTracker::PreCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView,
+                                                                    VkImageLayout imageLayout) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
 
     if (imageView != VK_NULL_HANDLE) {
@@ -6550,16 +6750,102 @@ void ValidationStateTracker::PreCallRecordCmdSetViewportShadingRatePaletteNV(VkC
     cb_state->status |= CBSTATUS_SHADING_RATE_PALETTE_SET;
 }
 
-void CoreChecks::PostCallRecordCreateAccelerationStructureNV(VkDevice device,
-                                                             const VkAccelerationStructureCreateInfoNV *pCreateInfo,
-                                                             const VkAllocationCallbacks *pAllocator,
-                                                             VkAccelerationStructureNV *pAccelerationStructure, VkResult result) {
+bool CoreChecks::ValidateGeometryTrianglesNV(const VkGeometryTrianglesNV &triangles, VkDebugReportObjectTypeEXT object_type,
+                                             uint64_t object_handle, const char *func_name) const {
+    bool skip = false;
+
+    const BUFFER_STATE *vb_state = GetBufferState(triangles.vertexData);
+    if (vb_state != nullptr && vb_state->binding.size <= triangles.vertexOffset) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryTrianglesNV-vertexOffset-02428", "%s", func_name);
+    }
+
+    const BUFFER_STATE *ib_state = GetBufferState(triangles.indexData);
+    if (ib_state != nullptr && ib_state->binding.size <= triangles.indexOffset) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryTrianglesNV-indexOffset-02431", "%s", func_name);
+    }
+
+    const BUFFER_STATE *td_state = GetBufferState(triangles.transformData);
+    if (td_state != nullptr && td_state->binding.size <= triangles.transformOffset) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryTrianglesNV-transformOffset-02437", "%s", func_name);
+    }
+
+    return skip;
+}
+
+bool CoreChecks::ValidateGeometryAABBNV(const VkGeometryAABBNV &aabbs, VkDebugReportObjectTypeEXT object_type,
+                                        uint64_t object_handle, const char *func_name) const {
+    bool skip = false;
+
+    const BUFFER_STATE *aabb_state = GetBufferState(aabbs.aabbData);
+    if (aabb_state != nullptr && aabb_state->binding.size > 0 && aabb_state->binding.size <= aabbs.offset) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryAABBNV-offset-02439", "%s", func_name);
+    }
+
+    return skip;
+}
+
+bool CoreChecks::ValidateGeometryNV(const VkGeometryNV &geometry, VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
+                                    const char *func_name) const {
+    bool skip = false;
+    if (geometry.geometryType == VK_GEOMETRY_TYPE_TRIANGLES_NV) {
+        skip = ValidateGeometryTrianglesNV(geometry.geometry.triangles, object_type, object_handle, func_name);
+    } else if (geometry.geometryType == VK_GEOMETRY_TYPE_AABBS_NV) {
+        skip = ValidateGeometryAABBNV(geometry.geometry.aabbs, object_type, object_handle, func_name);
+    }
+    return skip;
+}
+
+bool CoreChecks::PreCallValidateCreateAccelerationStructureNV(VkDevice device,
+                                                              const VkAccelerationStructureCreateInfoNV *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator,
+                                                              VkAccelerationStructureNV *pAccelerationStructure) {
+    bool skip = false;
+    if (pCreateInfo != nullptr && pCreateInfo->info.type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV) {
+        for (uint32_t i = 0; i < pCreateInfo->info.geometryCount; i++) {
+            skip |= ValidateGeometryNV(pCreateInfo->info.pGeometries[i], VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
+                                       HandleToUint64(device), "vkCreateAccelerationStructureNV():");
+        }
+    }
+    return skip;
+}
+
+void ValidationStateTracker::PostCallRecordCreateAccelerationStructureNV(VkDevice device,
+                                                                         const VkAccelerationStructureCreateInfoNV *pCreateInfo,
+                                                                         const VkAllocationCallbacks *pAllocator,
+                                                                         VkAccelerationStructureNV *pAccelerationStructure,
+                                                                         VkResult result) {
     if (VK_SUCCESS != result) return;
     std::unique_ptr<ACCELERATION_STRUCTURE_STATE> as_state(new ACCELERATION_STRUCTURE_STATE(*pAccelerationStructure, pCreateInfo));
+
+    // Query the requirements in case the application doesn't (to avoid bind/validation time query)
+    VkAccelerationStructureMemoryRequirementsInfoNV as_memory_requirements_info = {};
+    as_memory_requirements_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
+    as_memory_requirements_info.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV;
+    as_memory_requirements_info.accelerationStructure = as_state->acceleration_structure;
+    DispatchGetAccelerationStructureMemoryRequirementsNV(device, &as_memory_requirements_info, &as_state->memory_requirements);
+
+    VkAccelerationStructureMemoryRequirementsInfoNV scratch_memory_req_info = {};
+    scratch_memory_req_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
+    scratch_memory_req_info.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV;
+    scratch_memory_req_info.accelerationStructure = as_state->acceleration_structure;
+    DispatchGetAccelerationStructureMemoryRequirementsNV(device, &scratch_memory_req_info,
+                                                         &as_state->build_scratch_memory_requirements);
+
+    VkAccelerationStructureMemoryRequirementsInfoNV update_memory_req_info = {};
+    update_memory_req_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
+    update_memory_req_info.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV;
+    update_memory_req_info.accelerationStructure = as_state->acceleration_structure;
+    DispatchGetAccelerationStructureMemoryRequirementsNV(device, &update_memory_req_info,
+                                                         &as_state->update_scratch_memory_requirements);
+
     accelerationStructureMap[*pAccelerationStructure] = std::move(as_state);
 }
 
-void CoreChecks::PostCallRecordGetAccelerationStructureMemoryRequirementsNV(
+void ValidationStateTracker::PostCallRecordGetAccelerationStructureMemoryRequirementsNV(
     VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV *pInfo, VkMemoryRequirements2KHR *pMemoryRequirements) {
     ACCELERATION_STRUCTURE_STATE *as_state = GetAccelerationStructureState(pInfo->accelerationStructure);
     if (as_state != nullptr) {
@@ -6575,77 +6861,99 @@ void CoreChecks::PostCallRecordGetAccelerationStructureMemoryRequirementsNV(
         }
     }
 }
-
-bool CoreChecks::PreCallValidateBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
-                                                                  const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) {
+bool CoreChecks::ValidateBindAccelerationStructureMemoryNV(VkDevice device,
+                                                           const VkBindAccelerationStructureMemoryInfoNV &info) const {
     bool skip = false;
-    for (uint32_t i = 0; i < bindInfoCount; i++) {
-        const VkBindAccelerationStructureMemoryInfoNV &info = pBindInfos[i];
 
-        ACCELERATION_STRUCTURE_STATE *as_state = GetAccelerationStructureState(info.accelerationStructure);
-        if (!as_state) {
-            continue;
-        }
-        uint64_t as_handle = HandleToUint64(info.accelerationStructure);
-        if (!as_state->GetBoundMemory().empty()) {
-            skip |= log_msg(
-                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, as_handle,
-                "VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-02450",
-                "vkBindAccelerationStructureMemoryNV(): accelerationStructure must not already be backed by a memory object.");
-        }
-
-        if (!as_state->memory_requirements_checked) {
-            VkAccelerationStructureMemoryRequirementsInfoNV as_memory_requirements_info = {};
-            as_memory_requirements_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
-            as_memory_requirements_info.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV;
-            as_memory_requirements_info.accelerationStructure = as_state->acceleration_structure;
-            DispatchGetAccelerationStructureMemoryRequirementsNV(device, &as_memory_requirements_info,
-                                                                 &as_state->memory_requirements);
-            as_state->memory_requirements_checked = true;
-        }
+    const ACCELERATION_STRUCTURE_STATE *as_state = GetAccelerationStructureState(info.accelerationStructure);
+    if (!as_state) {
+        return skip;
+    }
+    uint64_t as_handle = HandleToUint64(info.accelerationStructure);
+    if (!as_state->GetBoundMemory().empty()) {
+        skip |=
+            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+                    as_handle, "VUID-VkBindAccelerationStructureMemoryInfoNV-accelerationStructure-02450",
+                    "vkBindAccelerationStructureMemoryNV(): accelerationStructure must not already be backed by a memory object.");
+    }
 
-        // Validate bound memory range information
-        const auto mem_info = GetDevMemState(info.memory);
-        if (mem_info) {
-            skip |= ValidateInsertAccelerationStructureMemoryRange(info.accelerationStructure, mem_info, info.memoryOffset,
-                                                                   as_state->memory_requirements.memoryRequirements,
-                                                                   "vkBindAccelerationStructureMemoryNV()");
-            skip |= ValidateMemoryTypes(mem_info, as_state->memory_requirements.memoryRequirements.memoryTypeBits,
-                                        "vkBindAccelerationStructureMemoryNV()",
-                                        "VUID-VkBindAccelerationStructureMemoryInfoNV-memory-02593");
-        }
+    if (!as_state->memory_requirements_checked) {
+        // There's not an explicit requirement in the spec to call vkGetImageMemoryRequirements() prior to calling
+        // BindAccelerationStructureMemoryNV but it's implied in that memory being bound must conform with
+        // VkAccelerationStructureMemoryRequirementsInfoNV from vkGetAccelerationStructureMemoryRequirementsNV
+        skip |= log_msg(
+            report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, as_handle,
+            kVUID_Core_BindAccelNV_NoMemReqQuery,
+            "vkBindAccelerationStructureMemoryNV(): "
+            "Binding memory to %s but vkGetAccelerationStructureMemoryRequirementsNV() has not been called on that structure.",
+            report_data->FormatHandle(info.accelerationStructure).c_str());
+        // Use requirements gathered at create time for validation below...
+    }
 
-        // Validate memory requirements alignment
-        if (SafeModulo(info.memoryOffset, as_state->memory_requirements.memoryRequirements.alignment) != 0) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
-                            as_handle, "VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-02594",
-                            "vkBindAccelerationStructureMemoryNV(): memoryOffset is 0x%" PRIxLEAST64
-                            " but must be an integer multiple of the VkMemoryRequirements::alignment value 0x%" PRIxLEAST64
+    // Validate bound memory range information
+    const auto mem_info = GetDevMemState(info.memory);
+    if (mem_info) {
+        skip |= ValidateInsertAccelerationStructureMemoryRange(info.accelerationStructure, mem_info, info.memoryOffset,
+                                                               as_state->memory_requirements.memoryRequirements,
+                                                               "vkBindAccelerationStructureMemoryNV()");
+        skip |= ValidateMemoryTypes(mem_info, as_state->memory_requirements.memoryRequirements.memoryTypeBits,
+                                    "vkBindAccelerationStructureMemoryNV()",
+                                    "VUID-VkBindAccelerationStructureMemoryInfoNV-memory-02593");
+    }
+
+    // Validate memory requirements alignment
+    if (SafeModulo(info.memoryOffset, as_state->memory_requirements.memoryRequirements.alignment) != 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+                        as_handle, "VUID-VkBindAccelerationStructureMemoryInfoNV-memoryOffset-02594",
+                        "vkBindAccelerationStructureMemoryNV(): memoryOffset is 0x%" PRIxLEAST64
+                        " but must be an integer multiple of the VkMemoryRequirements::alignment value 0x%" PRIxLEAST64
+                        ", returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure"
+                        "and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV.",
+                        info.memoryOffset, as_state->memory_requirements.memoryRequirements.alignment);
+    }
+
+    if (mem_info) {
+        // Validate memory requirements size
+        if (as_state->memory_requirements.memoryRequirements.size > (mem_info->alloc_info.allocationSize - info.memoryOffset)) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, as_handle,
+                            "VUID-VkBindAccelerationStructureMemoryInfoNV-size-02595",
+                            "vkBindAccelerationStructureMemoryNV(): memory size minus memoryOffset is 0x%" PRIxLEAST64
+                            " but must be at least as large as VkMemoryRequirements::size value 0x%" PRIxLEAST64
                             ", returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure"
                             "and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV.",
-                            info.memoryOffset, as_state->memory_requirements.memoryRequirements.alignment);
+                            mem_info->alloc_info.allocationSize - info.memoryOffset,
+                            as_state->memory_requirements.memoryRequirements.size);
         }
+    }
 
-        if (mem_info) {
-            // Validate memory requirements size
-            if (as_state->memory_requirements.memoryRequirements.size > (mem_info->alloc_info.allocationSize - info.memoryOffset)) {
-                skip |= log_msg(
-                    report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, as_handle,
-                    "VUID-VkBindAccelerationStructureMemoryInfoNV-size-02595",
-                    "vkBindAccelerationStructureMemoryNV(): memory size minus memoryOffset is 0x%" PRIxLEAST64
-                    " but must be at least as large as VkMemoryRequirements::size value 0x%" PRIxLEAST64
-                    ", returned from a call to vkGetAccelerationStructureMemoryRequirementsNV with accelerationStructure"
-                    "and type of VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV.",
-                    mem_info->alloc_info.allocationSize - info.memoryOffset, as_state->memory_requirements.memoryRequirements.size);
-            }
-        }
+    return skip;
+}
+bool CoreChecks::PreCallValidateBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
+                                                                  const VkBindAccelerationStructureMemoryInfoNV *pBindInfos) {
+    bool skip = false;
+    for (uint32_t i = 0; i < bindInfoCount; i++) {
+        skip |= ValidateBindAccelerationStructureMemoryNV(device, pBindInfos[i]);
     }
     return skip;
 }
 
-void CoreChecks::PostCallRecordBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
-                                                                 const VkBindAccelerationStructureMemoryInfoNV *pBindInfos,
-                                                                 VkResult result) {
+bool CoreChecks::PreCallValidateGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
+                                                                 size_t dataSize, void *pData) {
+    bool skip = false;
+
+    const ACCELERATION_STRUCTURE_STATE *as_state = GetAccelerationStructureState(accelerationStructure);
+    if (as_state != nullptr) {
+        // TODO: update the fake VUID below once the real one is generated.
+        skip = ValidateMemoryIsBoundToAccelerationStructure(
+            as_state, "vkGetAccelerationStructureHandleNV",
+            "UNASSIGNED-vkGetAccelerationStructureHandleNV-accelerationStructure-XXXX");
+    }
+
+    return skip;
+}
+
+void ValidationStateTracker::PostCallRecordBindAccelerationStructureMemoryNV(
+    VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV *pBindInfos, VkResult result) {
     if (VK_SUCCESS != result) return;
     for (uint32_t i = 0; i < bindInfoCount; i++) {
         const VkBindAccelerationStructureMemoryInfoNV &info = pBindInfos[i];
@@ -6655,16 +6963,6 @@ void CoreChecks::PostCallRecordBindAccelerationStructureMemoryNV(VkDevice device
             // Track bound memory range information
             auto mem_info = GetDevMemState(info.memory);
             if (mem_info) {
-                if (!as_state->memory_requirements_checked) {
-                    VkAccelerationStructureMemoryRequirementsInfoNV as_memory_requirements_info = {};
-                    as_memory_requirements_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
-                    as_memory_requirements_info.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV;
-                    as_memory_requirements_info.accelerationStructure = as_state->acceleration_structure;
-                    DispatchGetAccelerationStructureMemoryRequirementsNV(device, &as_memory_requirements_info,
-                                                                         &as_state->memory_requirements);
-                    as_state->memory_requirements_checked = true;
-                }
-
                 InsertAccelerationStructureMemoryRange(info.accelerationStructure, mem_info, info.memoryOffset,
                                                        as_state->requirements);
             }
@@ -6680,13 +6978,20 @@ bool CoreChecks::PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer
                                                                 VkDeviceSize instanceOffset, VkBool32 update,
                                                                 VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
                                                                 VkBuffer scratch, VkDeviceSize scratchOffset) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     bool skip = ValidateCmdQueueFlags(cb_state, "vkCmdBuildAccelerationStructureNV()", VK_QUEUE_COMPUTE_BIT,
                                       "VUID-vkCmdBuildAccelerationStructureNV-commandBuffer-cmdpool");
 
     skip |= ValidateCmd(cb_state, CMD_BUILDACCELERATIONSTRUCTURENV, "vkCmdBuildAccelerationStructureNV()");
 
+    if (pInfo != nullptr && pInfo->type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV) {
+        for (uint32_t i = 0; i < pInfo->geometryCount; i++) {
+            skip |= ValidateGeometryNV(pInfo->pGeometries[i], VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+                                       HandleToUint64(device), "vkCmdBuildAccelerationStructureNV():");
+        }
+    }
+
     if (pInfo != nullptr && pInfo->geometryCount > phys_dev_ext_props.ray_tracing_props.maxGeometryCount) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                         HandleToUint64(commandBuffer), "VUID-vkCmdBuildAccelerationStructureNV-geometryCount-02241",
@@ -6695,9 +7000,9 @@ bool CoreChecks::PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer
                         pInfo->geometryCount);
     }
 
-    ACCELERATION_STRUCTURE_STATE *dst_as_state = GetAccelerationStructureState(dst);
-    ACCELERATION_STRUCTURE_STATE *src_as_state = GetAccelerationStructureState(src);
-    BUFFER_STATE *scratch_buffer_state = GetBufferState(scratch);
+    const ACCELERATION_STRUCTURE_STATE *dst_as_state = GetAccelerationStructureState(dst);
+    const ACCELERATION_STRUCTURE_STATE *src_as_state = GetAccelerationStructureState(src);
+    const BUFFER_STATE *scratch_buffer_state = GetBufferState(scratch);
 
     if (dst_as_state != nullptr && pInfo != nullptr) {
         if (dst_as_state->create_info.info.type != pInfo->type) {
@@ -6784,16 +7089,14 @@ bool CoreChecks::PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer
             }
         }
         if (dst_as_state != nullptr && !dst_as_state->update_scratch_memory_requirements_checked) {
-            VkAccelerationStructureMemoryRequirementsInfoNV memoryRequirementsInfo = {};
-            memoryRequirementsInfo.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
-            memoryRequirementsInfo.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV;
-            memoryRequirementsInfo.accelerationStructure = dst;
-            DispatchGetAccelerationStructureMemoryRequirementsNV(device, &memoryRequirementsInfo,
-                                                                 &dst_as_state->update_scratch_memory_requirements);
-            dst_as_state->update_scratch_memory_requirements_checked = true;
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+                            HandleToUint64(dst), kVUID_Core_CmdBuildAccelNV_NoUpdateMemReqQuery,
+                            "vkCmdBuildAccelerationStructureNV(): Updating %s but vkGetAccelerationStructureMemoryRequirementsNV() "
+                            "has not been called for update scratch memory.",
+                            report_data->FormatHandle(dst_as_state->acceleration_structure).c_str());
+            // Use requirements fetched at create time
         }
         if (scratch_buffer_state != nullptr && dst_as_state != nullptr &&
-            dst_as_state->update_scratch_memory_requirements_checked &&
             dst_as_state->update_scratch_memory_requirements.memoryRequirements.size >
                 (scratch_buffer_state->binding.size - (scratch_buffer_state->binding.offset + scratchOffset))) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -6808,15 +7111,14 @@ bool CoreChecks::PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer
         }
     } else {
         if (dst_as_state != nullptr && !dst_as_state->build_scratch_memory_requirements_checked) {
-            VkAccelerationStructureMemoryRequirementsInfoNV memoryRequirementsInfo = {};
-            memoryRequirementsInfo.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV;
-            memoryRequirementsInfo.type = VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV;
-            memoryRequirementsInfo.accelerationStructure = dst;
-            DispatchGetAccelerationStructureMemoryRequirementsNV(device, &memoryRequirementsInfo,
-                                                                 &dst_as_state->build_scratch_memory_requirements);
-            dst_as_state->build_scratch_memory_requirements_checked = true;
-        }
-        if (scratch_buffer_state != nullptr && dst_as_state != nullptr && dst_as_state->build_scratch_memory_requirements_checked &&
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+                            HandleToUint64(dst), kVUID_Core_CmdBuildAccelNV_NoScratchMemReqQuery,
+                            "vkCmdBuildAccelerationStructureNV(): Assigning scratch buffer to %s but "
+                            "vkGetAccelerationStructureMemoryRequirementsNV() has not been called for scratch memory.",
+                            report_data->FormatHandle(dst_as_state->acceleration_structure).c_str());
+            // Use requirements fetched at create time
+        }
+        if (scratch_buffer_state != nullptr && dst_as_state != nullptr &&
             dst_as_state->build_scratch_memory_requirements.memoryRequirements.size >
                 (scratch_buffer_state->binding.size - (scratch_buffer_state->binding.offset + scratchOffset))) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -6833,11 +7135,9 @@ bool CoreChecks::PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer
     return skip;
 }
 
-void CoreChecks::PostCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer,
-                                                               const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData,
-                                                               VkDeviceSize instanceOffset, VkBool32 update,
-                                                               VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
-                                                               VkBuffer scratch, VkDeviceSize scratchOffset) {
+void ValidationStateTracker::PostCallRecordCmdBuildAccelerationStructureNV(
+    VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV *pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset,
+    VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     if (cb_state) {
         ACCELERATION_STRUCTURE_STATE *dst_as_state = GetAccelerationStructureState(dst);
@@ -6856,15 +7156,15 @@ void CoreChecks::PostCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer c
 bool CoreChecks::PreCallValidateCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
                                                                VkAccelerationStructureNV src,
                                                                VkCopyAccelerationStructureModeNV mode) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     bool skip = ValidateCmdQueueFlags(cb_state, "vkCmdCopyAccelerationStructureNV()", VK_QUEUE_COMPUTE_BIT,
                                       "VUID-vkCmdCopyAccelerationStructureNV-commandBuffer-cmdpool");
 
     skip |= ValidateCmd(cb_state, CMD_COPYACCELERATIONSTRUCTURENV, "vkCmdCopyAccelerationStructureNV()");
 
-    ACCELERATION_STRUCTURE_STATE *dst_as_state = GetAccelerationStructureState(dst);
-    ACCELERATION_STRUCTURE_STATE *src_as_state = GetAccelerationStructureState(src);
+    const ACCELERATION_STRUCTURE_STATE *dst_as_state = GetAccelerationStructureState(dst);
+    const ACCELERATION_STRUCTURE_STATE *src_as_state = GetAccelerationStructureState(src);
 
     if (dst_as_state != nullptr) {
         skip |= ValidateMemoryIsBoundToAccelerationStructure(
@@ -6885,9 +7185,10 @@ bool CoreChecks::PreCallValidateCmdCopyAccelerationStructureNV(VkCommandBuffer c
     return skip;
 }
 
-void CoreChecks::PostCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
-                                                              VkAccelerationStructureNV src,
-                                                              VkCopyAccelerationStructureModeNV mode) {
+void ValidationStateTracker::PostCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer,
+                                                                          VkAccelerationStructureNV dst,
+                                                                          VkAccelerationStructureNV src,
+                                                                          VkCopyAccelerationStructureModeNV mode) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     if (cb_state) {
         ACCELERATION_STRUCTURE_STATE *src_as_state = GetAccelerationStructureState(src);
@@ -6903,7 +7204,7 @@ void CoreChecks::PostCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer co
 
 bool CoreChecks::PreCallValidateDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
                                                                const VkAllocationCallbacks *pAllocator) {
-    ACCELERATION_STRUCTURE_STATE *as_state = GetAccelerationStructureState(accelerationStructure);
+    const ACCELERATION_STRUCTURE_STATE *as_state = GetAccelerationStructureState(accelerationStructure);
     const VulkanTypedHandle obj_struct(accelerationStructure, kVulkanObjectTypeAccelerationStructureNV);
     bool skip = false;
     if (as_state) {
@@ -6913,8 +7214,9 @@ bool CoreChecks::PreCallValidateDestroyAccelerationStructureNV(VkDevice device,
     return skip;
 }
 
-void CoreChecks::PreCallRecordDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
-                                                             const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroyAccelerationStructureNV(VkDevice device,
+                                                                         VkAccelerationStructureNV accelerationStructure,
+                                                                         const VkAllocationCallbacks *pAllocator) {
     if (!accelerationStructure) return;
     auto *as_state = GetAccelerationStructureState(accelerationStructure);
     if (as_state) {
@@ -6951,6 +7253,28 @@ void ValidationStateTracker::PreCallRecordCmdSetLineWidth(VkCommandBuffer comman
     cb_state->status |= CBSTATUS_LINE_WIDTH_SET;
 }
 
+bool CoreChecks::PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                     uint16_t lineStipplePattern) {
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    assert(cb_state);
+    bool skip = ValidateCmdQueueFlags(cb_state, "vkCmdSetLineStippleEXT()", VK_QUEUE_GRAPHICS_BIT,
+                                      "VUID-vkCmdSetLineStippleEXT-commandBuffer-cmdpool");
+    skip |= ValidateCmd(cb_state, CMD_SETLINESTIPPLEEXT, "vkCmdSetLineStippleEXT()");
+
+    if (cb_state->static_status & CBSTATUS_LINE_STIPPLE_SET) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        HandleToUint64(commandBuffer), "VUID-vkCmdSetLineStippleEXT-None-02775",
+                        "vkCmdSetLineStippleEXT called but pipeline was created without VK_DYNAMIC_STATE_LINE_STIPPLE_EXT flag.");
+    }
+    return skip;
+}
+
+void ValidationStateTracker::PreCallRecordCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                               uint16_t lineStipplePattern) {
+    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    cb_state->status |= CBSTATUS_LINE_STIPPLE_SET;
+}
+
 bool CoreChecks::PreCallValidateCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp,
                                                 float depthBiasSlopeFactor) {
     const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
@@ -7080,15 +7404,16 @@ void ValidationStateTracker::PreCallRecordCmdSetStencilReference(VkCommandBuffer
     cb_state->status |= CBSTATUS_STENCIL_REFERENCE_SET;
 }
 
-// Update pipeline_layout bind points applying the "Pipeline Layout Compatibility" rules
+// Update pipeline_layout bind points applying the "Pipeline Layout Compatibility" rules.
+// One of pDescriptorSets or push_descriptor_set should be nullptr, indicating whether this
+// is called for CmdBindDescriptorSets or CmdPushDescriptorSet.
 void ValidationStateTracker::UpdateLastBoundDescriptorSets(CMD_BUFFER_STATE *cb_state, VkPipelineBindPoint pipeline_bind_point,
                                                            const PIPELINE_LAYOUT_STATE *pipeline_layout, uint32_t first_set,
-                                                           uint32_t set_count,
-                                                           const std::vector<cvdescriptorset::DescriptorSet *> descriptor_sets,
+                                                           uint32_t set_count, const VkDescriptorSet *pDescriptorSets,
+                                                           cvdescriptorset::DescriptorSet *push_descriptor_set,
                                                            uint32_t dynamic_offset_count, const uint32_t *p_dynamic_offsets) {
+    assert((pDescriptorSets == nullptr) ^ (push_descriptor_set == nullptr));
     // Defensive
-    assert(set_count);
-    if (0 == set_count) return;
     assert(pipeline_layout);
     if (!pipeline_layout) return;
 
@@ -7098,15 +7423,8 @@ void ValidationStateTracker::UpdateLastBoundDescriptorSets(CMD_BUFFER_STATE *cb_
 
     // Some useful shorthand
     auto &last_bound = cb_state->lastBound[pipeline_bind_point];
-
-    auto &bound_sets = last_bound.boundDescriptorSets;
-    auto &dynamic_offsets = last_bound.dynamicOffsets;
-    auto &bound_compat_ids = last_bound.compat_id_for_set;
     auto &pipe_compat_ids = pipeline_layout->compat_for_set;
-
-    const uint32_t current_size = static_cast<uint32_t>(bound_sets.size());
-    assert(current_size == dynamic_offsets.size());
-    assert(current_size == bound_compat_ids.size());
+    const uint32_t current_size = static_cast<uint32_t>(last_bound.per_set.size());
 
     // We need this three times in this function, but nowhere else
     auto push_descriptor_cleanup = [&last_bound](const cvdescriptorset::DescriptorSet *ds) -> bool {
@@ -7120,10 +7438,10 @@ void ValidationStateTracker::UpdateLastBoundDescriptorSets(CMD_BUFFER_STATE *cb_
 
     // Clean up the "disturbed" before and after the range to be set
     if (required_size < current_size) {
-        if (bound_compat_ids[last_binding_index] != pipe_compat_ids[last_binding_index]) {
+        if (last_bound.per_set[last_binding_index].compat_id_for_set != pipe_compat_ids[last_binding_index]) {
             // We're disturbing those after last, we'll shrink below, but first need to check for and cleanup the push_descriptor
             for (auto set_idx = required_size; set_idx < current_size; ++set_idx) {
-                if (push_descriptor_cleanup(bound_sets[set_idx])) break;
+                if (push_descriptor_cleanup(last_bound.per_set[set_idx].bound_descriptor_set)) break;
             }
         } else {
             // We're not disturbing past last, so leave the upper binding data alone.
@@ -7133,19 +7451,16 @@ void ValidationStateTracker::UpdateLastBoundDescriptorSets(CMD_BUFFER_STATE *cb_
 
     // We resize if we need more set entries or if those past "last" are disturbed
     if (required_size != current_size) {
-        // TODO: put these size tied things in a struct (touches many lines)
-        bound_sets.resize(required_size);
-        dynamic_offsets.resize(required_size);
-        bound_compat_ids.resize(required_size);
+        last_bound.per_set.resize(required_size);
     }
 
     // For any previously bound sets, need to set them to "invalid" if they were disturbed by this update
     for (uint32_t set_idx = 0; set_idx < first_set; ++set_idx) {
-        if (bound_compat_ids[set_idx] != pipe_compat_ids[set_idx]) {
-            push_descriptor_cleanup(bound_sets[set_idx]);
-            bound_sets[set_idx] = nullptr;
-            dynamic_offsets[set_idx].clear();
-            bound_compat_ids[set_idx] = pipe_compat_ids[set_idx];
+        if (last_bound.per_set[set_idx].compat_id_for_set != pipe_compat_ids[set_idx]) {
+            push_descriptor_cleanup(last_bound.per_set[set_idx].bound_descriptor_set);
+            last_bound.per_set[set_idx].bound_descriptor_set = nullptr;
+            last_bound.per_set[set_idx].dynamicOffsets.clear();
+            last_bound.per_set[set_idx].compat_id_for_set = pipe_compat_ids[set_idx];
         }
     }
 
@@ -7153,26 +7468,27 @@ void ValidationStateTracker::UpdateLastBoundDescriptorSets(CMD_BUFFER_STATE *cb_
     const uint32_t *input_dynamic_offsets = p_dynamic_offsets;  // "read" pointer for dynamic offset data
     for (uint32_t input_idx = 0; input_idx < set_count; input_idx++) {
         auto set_idx = input_idx + first_set;  // set_idx is index within layout, input_idx is index within input descriptor sets
-        cvdescriptorset::DescriptorSet *descriptor_set = descriptor_sets[input_idx];
+        cvdescriptorset::DescriptorSet *descriptor_set =
+            push_descriptor_set ? push_descriptor_set : GetSetNode(pDescriptorSets[input_idx]);
 
         // Record binding (or push)
         if (descriptor_set != last_bound.push_descriptor_set.get()) {
             // Only cleanup the push descriptors if they aren't the currently used set.
-            push_descriptor_cleanup(bound_sets[set_idx]);
+            push_descriptor_cleanup(last_bound.per_set[set_idx].bound_descriptor_set);
         }
-        bound_sets[set_idx] = descriptor_set;
-        bound_compat_ids[set_idx] = pipe_compat_ids[set_idx];  // compat ids are canonical *per* set index
+        last_bound.per_set[set_idx].bound_descriptor_set = descriptor_set;
+        last_bound.per_set[set_idx].compat_id_for_set = pipe_compat_ids[set_idx];  // compat ids are canonical *per* set index
 
         if (descriptor_set) {
             auto set_dynamic_descriptor_count = descriptor_set->GetDynamicDescriptorCount();
             // TODO: Add logic for tracking push_descriptor offsets (here or in caller)
             if (set_dynamic_descriptor_count && input_dynamic_offsets) {
                 const uint32_t *end_offset = input_dynamic_offsets + set_dynamic_descriptor_count;
-                dynamic_offsets[set_idx] = std::vector<uint32_t>(input_dynamic_offsets, end_offset);
+                last_bound.per_set[set_idx].dynamicOffsets = std::vector<uint32_t>(input_dynamic_offsets, end_offset);
                 input_dynamic_offsets = end_offset;
                 assert(input_dynamic_offsets <= (p_dynamic_offsets + dynamic_offset_count));
             } else {
-                dynamic_offsets[set_idx].clear();
+                last_bound.per_set[set_idx].dynamicOffsets.clear();
             }
             if (!descriptor_set->IsPushDescriptor()) {
                 // Can't cache validation of push_descriptors
@@ -7190,29 +7506,16 @@ void ValidationStateTracker::PreCallRecordCmdBindDescriptorSets(VkCommandBuffer
                                                                 const uint32_t *pDynamicOffsets) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     auto pipeline_layout = GetPipelineLayout(layout);
-    std::vector<cvdescriptorset::DescriptorSet *> descriptor_sets;
-    descriptor_sets.reserve(setCount);
 
     // Resize binding arrays
     uint32_t last_set_index = firstSet + setCount - 1;
-    if (last_set_index >= cb_state->lastBound[pipelineBindPoint].boundDescriptorSets.size()) {
-        cb_state->lastBound[pipelineBindPoint].boundDescriptorSets.resize(last_set_index + 1);
-        cb_state->lastBound[pipelineBindPoint].dynamicOffsets.resize(last_set_index + 1);
-        cb_state->lastBound[pipelineBindPoint].compat_id_for_set.resize(last_set_index + 1);
+    if (last_set_index >= cb_state->lastBound[pipelineBindPoint].per_set.size()) {
+        cb_state->lastBound[pipelineBindPoint].per_set.resize(last_set_index + 1);
     }
 
-    // Construct a list of the descriptors
-    bool found_non_null = false;
-    for (uint32_t i = 0; i < setCount; i++) {
-        cvdescriptorset::DescriptorSet *descriptor_set = GetSetNode(pDescriptorSets[i]);
-        descriptor_sets.emplace_back(descriptor_set);
-        found_non_null |= descriptor_set != nullptr;
-    }
-    if (found_non_null) {  // which implies setCount > 0
-        UpdateLastBoundDescriptorSets(cb_state, pipelineBindPoint, pipeline_layout, firstSet, setCount, descriptor_sets,
-                                      dynamicOffsetCount, pDynamicOffsets);
-        cb_state->lastBound[pipelineBindPoint].pipeline_layout = layout;
-    }
+    UpdateLastBoundDescriptorSets(cb_state, pipelineBindPoint, pipeline_layout, firstSet, setCount, pDescriptorSets, nullptr,
+                                  dynamicOffsetCount, pDynamicOffsets);
+    cb_state->lastBound[pipelineBindPoint].pipeline_layout = layout;
 }
 
 static bool ValidateDynamicOffsetAlignment(const debug_report_data *report_data, const VkDescriptorSetLayoutBinding *binding,
@@ -7407,12 +7710,12 @@ void CoreChecks::RecordCmdPushDescriptorSetState(CMD_BUFFER_STATE *cb_state, VkP
     auto &last_bound = cb_state->lastBound[pipelineBindPoint];
     auto &push_descriptor_set = last_bound.push_descriptor_set;
     // If we are disturbing the current push_desriptor_set clear it
-    if (!push_descriptor_set || !CompatForSet(set, last_bound.compat_id_for_set, pipeline_layout->compat_for_set)) {
+    if (!push_descriptor_set || !CompatForSet(set, last_bound, pipeline_layout->compat_for_set)) {
         last_bound.UnbindAndResetPushDescriptorSet(new cvdescriptorset::DescriptorSet(0, 0, dsl, 0, this));
     }
 
-    std::vector<cvdescriptorset::DescriptorSet *> descriptor_sets = {push_descriptor_set.get()};
-    UpdateLastBoundDescriptorSets(cb_state, pipelineBindPoint, pipeline_layout, set, 1, descriptor_sets, 0, nullptr);
+    UpdateLastBoundDescriptorSets(cb_state, pipelineBindPoint, pipeline_layout, set, 1, nullptr, push_descriptor_set.get(), 0,
+                                  nullptr);
     last_bound.pipeline_layout = layout;
 
     // Now that we have either the new or extant push_descriptor set ... do the write updates against it
@@ -7432,6 +7735,8 @@ static VkDeviceSize GetIndexAlignment(VkIndexType indexType) {
             return 2;
         case VK_INDEX_TYPE_UINT32:
             return 4;
+        case VK_INDEX_TYPE_UINT8_EXT:
+            return 1;
         default:
             // Not a real index type. Express no alignment requirement here; we expect upper layer
             // to have already picked up on the enum being nonsense.
@@ -7441,8 +7746,8 @@ static VkDeviceSize GetIndexAlignment(VkIndexType indexType) {
 
 bool CoreChecks::PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                    VkIndexType indexType) {
-    auto buffer_state = GetBufferState(buffer);
-    auto cb_node = GetCBState(commandBuffer);
+    const auto buffer_state = GetBufferState(buffer);
+    const auto cb_node = GetCBState(commandBuffer);
     assert(buffer_state);
     assert(cb_node);
 
@@ -7453,7 +7758,7 @@ bool CoreChecks::PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer
                                   "VUID-vkCmdBindIndexBuffer-commandBuffer-cmdpool");
     skip |= ValidateCmd(cb_node, CMD_BINDINDEXBUFFER, "vkCmdBindIndexBuffer()");
     skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdBindIndexBuffer()", "VUID-vkCmdBindIndexBuffer-buffer-00434");
-    auto offset_align = GetIndexAlignment(indexType);
+    const auto offset_align = GetIndexAlignment(indexType);
     if (offset % offset_align) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                         HandleToUint64(commandBuffer), "VUID-vkCmdBindIndexBuffer-offset-00432",
@@ -7464,28 +7769,30 @@ bool CoreChecks::PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                 VkIndexType indexType) {
+void ValidationStateTracker::PreCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                             VkIndexType indexType) {
     auto buffer_state = GetBufferState(buffer);
-    auto cb_node = GetCBState(commandBuffer);
+    auto cb_state = GetCBState(commandBuffer);
 
-    cb_node->status |= CBSTATUS_INDEX_BUFFER_BOUND;
-    cb_node->index_buffer_binding.buffer = buffer;
-    cb_node->index_buffer_binding.size = buffer_state->createInfo.size;
-    cb_node->index_buffer_binding.offset = offset;
-    cb_node->index_buffer_binding.index_type = indexType;
+    cb_state->status |= CBSTATUS_INDEX_BUFFER_BOUND;
+    cb_state->index_buffer_binding.buffer = buffer;
+    cb_state->index_buffer_binding.size = buffer_state->createInfo.size;
+    cb_state->index_buffer_binding.offset = offset;
+    cb_state->index_buffer_binding.index_type = indexType;
+    // Add binding for this index buffer to this commandbuffer
+    AddCommandBufferBindingBuffer(cb_state, buffer_state);
 }
 
 bool CoreChecks::PreCallValidateCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
                                                      const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) {
-    auto cb_state = GetCBState(commandBuffer);
+    const auto cb_state = GetCBState(commandBuffer);
     assert(cb_state);
 
     bool skip = ValidateCmdQueueFlags(cb_state, "vkCmdBindVertexBuffers()", VK_QUEUE_GRAPHICS_BIT,
                                       "VUID-vkCmdBindVertexBuffers-commandBuffer-cmdpool");
     skip |= ValidateCmd(cb_state, CMD_BINDVERTEXBUFFERS, "vkCmdBindVertexBuffers()");
     for (uint32_t i = 0; i < bindingCount; ++i) {
-        auto buffer_state = GetBufferState(pBuffers[i]);
+        const auto buffer_state = GetBufferState(pBuffers[i]);
         assert(buffer_state);
         skip |= ValidateBufferUsageFlags(buffer_state, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, true,
                                          "VUID-vkCmdBindVertexBuffers-pBuffers-00627", "vkCmdBindVertexBuffers()",
@@ -7501,19 +7808,22 @@ bool CoreChecks::PreCallValidateCmdBindVertexBuffers(VkCommandBuffer commandBuff
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
-                                                   const VkBuffer *pBuffers, const VkDeviceSize *pOffsets) {
+void ValidationStateTracker::PreCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
+                                                               uint32_t bindingCount, const VkBuffer *pBuffers,
+                                                               const VkDeviceSize *pOffsets) {
     auto cb_state = GetCBState(commandBuffer);
 
     uint32_t end = firstBinding + bindingCount;
-    if (cb_state->current_draw_data.vertex_buffer_bindings.size() < end) {
-        cb_state->current_draw_data.vertex_buffer_bindings.resize(end);
+    if (cb_state->current_vertex_buffer_binding_info.vertex_buffer_bindings.size() < end) {
+        cb_state->current_vertex_buffer_binding_info.vertex_buffer_bindings.resize(end);
     }
 
     for (uint32_t i = 0; i < bindingCount; ++i) {
-        auto &vertex_buffer_binding = cb_state->current_draw_data.vertex_buffer_bindings[i + firstBinding];
+        auto &vertex_buffer_binding = cb_state->current_vertex_buffer_binding_info.vertex_buffer_bindings[i + firstBinding];
         vertex_buffer_binding.buffer = pBuffers[i];
         vertex_buffer_binding.offset = pOffsets[i];
+        // Add binding for this vertex buffer to this commandbuffer
+        AddCommandBufferBindingBuffer(cb_state, GetBufferState(pBuffers[i]));
     }
 }
 
@@ -7863,7 +8173,7 @@ bool CoreChecks::ValidateRenderPassImageBarriers(const char *funcName, CMD_BUFFE
         if (VK_NULL_HANDLE == cb_state->activeFramebuffer) {
             assert(VK_COMMAND_BUFFER_LEVEL_SECONDARY == cb_state->createInfo.level);
             // Secondary CB case w/o FB specified delay validation
-            cb_state->cmd_execute_commands_functions.emplace_back([=](CMD_BUFFER_STATE *primary_cb, VkFramebuffer fb) {
+            cb_state->cmd_execute_commands_functions.emplace_back([=](const CMD_BUFFER_STATE *primary_cb, VkFramebuffer fb) {
                 return ValidateImageBarrierImage(funcName, cb_state, fb, active_subpass, sub_desc, rp_handle, i, img_barrier);
             });
         } else {
@@ -8292,31 +8602,31 @@ bool Validate(const CoreChecks *device_data, const char *func_name, CMD_BUFFER_S
 
 // Type specific wrapper for image barriers
 bool CoreChecks::ValidateBarrierQueueFamilies(const char *func_name, CMD_BUFFER_STATE *cb_state,
-                                              const VkImageMemoryBarrier *barrier, const IMAGE_STATE *state_data) {
+                                              const VkImageMemoryBarrier &barrier, const IMAGE_STATE *state_data) {
     // State data is required
     if (!state_data) {
         return false;
     }
 
     // Create the validator state from the image state
-    barrier_queue_families::ValidatorState val(this, func_name, cb_state, barrier, state_data);
-    const uint32_t src_queue_family = barrier->srcQueueFamilyIndex;
-    const uint32_t dst_queue_family = barrier->dstQueueFamilyIndex;
+    barrier_queue_families::ValidatorState val(this, func_name, cb_state, &barrier, state_data);
+    const uint32_t src_queue_family = barrier.srcQueueFamilyIndex;
+    const uint32_t dst_queue_family = barrier.dstQueueFamilyIndex;
     return barrier_queue_families::Validate(this, func_name, cb_state, val, src_queue_family, dst_queue_family);
 }
 
 // Type specific wrapper for buffer barriers
 bool CoreChecks::ValidateBarrierQueueFamilies(const char *func_name, CMD_BUFFER_STATE *cb_state,
-                                              const VkBufferMemoryBarrier *barrier, const BUFFER_STATE *state_data) {
+                                              const VkBufferMemoryBarrier &barrier, const BUFFER_STATE *state_data) {
     // State data is required
     if (!state_data) {
         return false;
     }
 
     // Create the validator state from the buffer state
-    barrier_queue_families::ValidatorState val(this, func_name, cb_state, barrier, state_data);
-    const uint32_t src_queue_family = barrier->srcQueueFamilyIndex;
-    const uint32_t dst_queue_family = barrier->dstQueueFamilyIndex;
+    barrier_queue_families::ValidatorState val(this, func_name, cb_state, &barrier, state_data);
+    const uint32_t src_queue_family = barrier.srcQueueFamilyIndex;
+    const uint32_t dst_queue_family = barrier.dstQueueFamilyIndex;
     return barrier_queue_families::Validate(this, func_name, cb_state, val, src_queue_family, dst_queue_family);
 }
 
@@ -8342,24 +8652,24 @@ bool CoreChecks::ValidateBarriers(const char *funcName, CMD_BUFFER_STATE *cb_sta
         }
     }
     for (uint32_t i = 0; i < imageMemBarrierCount; ++i) {
-        auto mem_barrier = &pImageMemBarriers[i];
-        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier->srcAccessMask, src_stage_mask)) {
+        const auto &mem_barrier = pImageMemBarriers[i];
+        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier.srcAccessMask, src_stage_mask)) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             HandleToUint64(cb_state->commandBuffer), "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184",
                             "%s: pImageMemBarriers[%d].srcAccessMask (0x%X) is not supported by srcStageMask (0x%X).", funcName, i,
-                            mem_barrier->srcAccessMask, src_stage_mask);
+                            mem_barrier.srcAccessMask, src_stage_mask);
         }
-        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier->dstAccessMask, dst_stage_mask)) {
+        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier.dstAccessMask, dst_stage_mask)) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             HandleToUint64(cb_state->commandBuffer), "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185",
                             "%s: pImageMemBarriers[%d].dstAccessMask (0x%X) is not supported by dstStageMask (0x%X).", funcName, i,
-                            mem_barrier->dstAccessMask, dst_stage_mask);
+                            mem_barrier.dstAccessMask, dst_stage_mask);
         }
 
-        auto image_data = GetImageState(mem_barrier->image);
+        auto image_data = GetImageState(mem_barrier.image);
         skip |= ValidateBarrierQueueFamilies(funcName, cb_state, mem_barrier, image_data);
 
-        if (mem_barrier->newLayout == VK_IMAGE_LAYOUT_UNDEFINED || mem_barrier->newLayout == VK_IMAGE_LAYOUT_PREINITIALIZED) {
+        if (mem_barrier.newLayout == VK_IMAGE_LAYOUT_UNDEFINED || mem_barrier.newLayout == VK_IMAGE_LAYOUT_PREINITIALIZED) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             HandleToUint64(cb_state->commandBuffer), "VUID-VkImageMemoryBarrier-newLayout-01198",
                             "%s: Image Layout cannot be transitioned to UNDEFINED or PREINITIALIZED.", funcName);
@@ -8372,32 +8682,31 @@ bool CoreChecks::ValidateBarriers(const char *funcName, CMD_BUFFER_STATE *cb_sta
             // TODO: Update this when VUID is defined
             skip |= ValidateMemoryIsBoundToImage(image_data, funcName, kVUIDUndefined);
 
-            auto aspect_mask = mem_barrier->subresourceRange.aspectMask;
+            const auto aspect_mask = mem_barrier.subresourceRange.aspectMask;
             skip |= ValidateImageAspectMask(image_data->image, image_data->createInfo.format, aspect_mask, funcName);
 
-            std::string param_name = "pImageMemoryBarriers[" + std::to_string(i) + "].subresourceRange";
-            skip |= ValidateImageBarrierSubresourceRange(image_data, mem_barrier->subresourceRange, funcName, param_name.c_str());
+            const std::string param_name = "pImageMemoryBarriers[" + std::to_string(i) + "].subresourceRange";
+            skip |= ValidateImageBarrierSubresourceRange(image_data, mem_barrier.subresourceRange, funcName, param_name.c_str());
         }
     }
 
     for (uint32_t i = 0; i < bufferBarrierCount; ++i) {
-        auto mem_barrier = &pBufferMemBarriers[i];
-        if (!mem_barrier) continue;
+        const auto &mem_barrier = pBufferMemBarriers[i];
 
-        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier->srcAccessMask, src_stage_mask)) {
+        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier.srcAccessMask, src_stage_mask)) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             HandleToUint64(cb_state->commandBuffer), "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01184",
                             "%s: pBufferMemBarriers[%d].srcAccessMask (0x%X) is not supported by srcStageMask (0x%X).", funcName, i,
-                            mem_barrier->srcAccessMask, src_stage_mask);
+                            mem_barrier.srcAccessMask, src_stage_mask);
         }
-        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier->dstAccessMask, dst_stage_mask)) {
+        if (!ValidateAccessMaskPipelineStage(device_extensions, mem_barrier.dstAccessMask, dst_stage_mask)) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                             HandleToUint64(cb_state->commandBuffer), "VUID-vkCmdPipelineBarrier-pMemoryBarriers-01185",
                             "%s: pBufferMemBarriers[%d].dstAccessMask (0x%X) is not supported by dstStageMask (0x%X).", funcName, i,
-                            mem_barrier->dstAccessMask, dst_stage_mask);
+                            mem_barrier.dstAccessMask, dst_stage_mask);
         }
         // Validate buffer barrier queue family indices
-        auto buffer_state = GetBufferState(mem_barrier->buffer);
+        auto buffer_state = GetBufferState(mem_barrier.buffer);
         skip |= ValidateBarrierQueueFamilies(funcName, cb_state, mem_barrier, buffer_state);
 
         if (buffer_state) {
@@ -8408,20 +8717,19 @@ bool CoreChecks::ValidateBarriers(const char *funcName, CMD_BUFFER_STATE *cb_sta
             skip |= ValidateMemoryIsBoundToBuffer(buffer_state, funcName, kVUIDUndefined);
 
             auto buffer_size = buffer_state->createInfo.size;
-            if (mem_barrier->offset >= buffer_size) {
+            if (mem_barrier.offset >= buffer_size) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                                 HandleToUint64(cb_state->commandBuffer), "VUID-VkBufferMemoryBarrier-offset-01187",
                                 "%s: Buffer Barrier %s has offset 0x%" PRIx64 " which is not less than total size 0x%" PRIx64 ".",
-                                funcName, report_data->FormatHandle(mem_barrier->buffer).c_str(),
-                                HandleToUint64(mem_barrier->offset), HandleToUint64(buffer_size));
-            } else if (mem_barrier->size != VK_WHOLE_SIZE && (mem_barrier->offset + mem_barrier->size > buffer_size)) {
-                skip |=
-                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                            HandleToUint64(cb_state->commandBuffer), "VUID-VkBufferMemoryBarrier-size-01189",
-                            "%s: Buffer Barrier %s has offset 0x%" PRIx64 " and size 0x%" PRIx64
-                            " whose sum is greater than total size 0x%" PRIx64 ".",
-                            funcName, report_data->FormatHandle(mem_barrier->buffer).c_str(), HandleToUint64(mem_barrier->offset),
-                            HandleToUint64(mem_barrier->size), HandleToUint64(buffer_size));
+                                funcName, report_data->FormatHandle(mem_barrier.buffer).c_str(), HandleToUint64(mem_barrier.offset),
+                                HandleToUint64(buffer_size));
+            } else if (mem_barrier.size != VK_WHOLE_SIZE && (mem_barrier.offset + mem_barrier.size > buffer_size)) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                                HandleToUint64(cb_state->commandBuffer), "VUID-VkBufferMemoryBarrier-size-01189",
+                                "%s: Buffer Barrier %s has offset 0x%" PRIx64 " and size 0x%" PRIx64
+                                " whose sum is greater than total size 0x%" PRIx64 ".",
+                                funcName, report_data->FormatHandle(mem_barrier.buffer).c_str(), HandleToUint64(mem_barrier.offset),
+                                HandleToUint64(mem_barrier.size), HandleToUint64(buffer_size));
             }
         }
     }
@@ -8695,7 +9003,7 @@ void CoreChecks::PreCallRecordCmdPipelineBarrier(VkCommandBuffer commandBuffer,
     TransitionImageLayouts(cb_state, imageMemoryBarrierCount, pImageMemoryBarriers);
 }
 
-bool CoreChecks::SetQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject object, QueryState value) {
+bool ValidationStateTracker::SetQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject object, QueryState value) {
     CMD_BUFFER_STATE *pCB = GetCBState(commandBuffer);
     if (pCB) {
         pCB->queryToStateMap[object] = value;
@@ -8707,9 +9015,27 @@ bool CoreChecks::SetQueryState(VkQueue queue, VkCommandBuffer commandBuffer, Que
     return false;
 }
 
+bool ValidationStateTracker::SetQueryStateMulti(VkQueue queue, VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                uint32_t firstQuery, uint32_t queryCount, QueryState value) {
+    CMD_BUFFER_STATE *pCB = GetCBState(commandBuffer);
+    auto queue_data = queueMap.find(queue);
+
+    for (uint32_t i = 0; i < queryCount; i++) {
+        QueryObject object = {queryPool, firstQuery + i};
+        if (pCB) {
+            pCB->queryToStateMap[object] = value;
+        }
+        if (queue_data != queueMap.end()) {
+            queue_data->second.queryToStateMap[object] = value;
+        }
+    }
+    return false;
+}
+
 bool CoreChecks::ValidateBeginQuery(const CMD_BUFFER_STATE *cb_state, const QueryObject &query_obj, VkFlags flags, CMD_TYPE cmd,
                                     const char *cmd_name, const char *vuid_queue_flags, const char *vuid_queue_feedback,
-                                    const char *vuid_queue_occlusion, const char *vuid_precise, const char *vuid_query_count) {
+                                    const char *vuid_queue_occlusion, const char *vuid_precise,
+                                    const char *vuid_query_count) const {
     bool skip = false;
     const auto &query_pool_ci = GetQueryPoolState(query_obj.pool)->createInfo;
 
@@ -8750,14 +9076,12 @@ bool CoreChecks::ValidateBeginQuery(const CMD_BUFFER_STATE *cb_state, const Quer
     return skip;
 }
 
-void CoreChecks::RecordBeginQuery(CMD_BUFFER_STATE *cb_state, const QueryObject &query_obj) {
+void ValidationStateTracker::RecordCmdBeginQuery(CMD_BUFFER_STATE *cb_state, const QueryObject &query_obj) {
     cb_state->activeQueries.insert(query_obj);
     cb_state->startedQueries.insert(query_obj);
     cb_state->queryUpdates.emplace_back([this, cb_state, query_obj](VkQueue q) {
-        bool skip = false;
-        skip |= VerifyQueryIsReset(q, cb_state->commandBuffer, query_obj);
-        skip |= SetQueryState(q, cb_state->commandBuffer, query_obj, QUERYSTATE_RUNNING);
-        return skip;
+        SetQueryState(q, cb_state->commandBuffer, query_obj, QUERYSTATE_RUNNING);
+        return false;
     });
     AddCommandBufferBinding(&GetQueryPoolState(query_obj.pool)->cb_bindings,
                             VulkanTypedHandle(query_obj.pool, kVulkanObjectTypeQueryPool), cb_state);
@@ -8765,7 +9089,7 @@ void CoreChecks::RecordBeginQuery(CMD_BUFFER_STATE *cb_state, const QueryObject
 
 bool CoreChecks::PreCallValidateCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) {
     if (disabled.query_validation) return false;
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     QueryObject query_obj(queryPool, slot);
     return ValidateBeginQuery(cb_state, query_obj, flags, CMD_BEGINQUERY, "vkCmdBeginQuery()",
@@ -8774,7 +9098,7 @@ bool CoreChecks::PreCallValidateCmdBeginQuery(VkCommandBuffer commandBuffer, VkQ
                               "VUID-vkCmdBeginQuery-query-00802");
 }
 
-bool CoreChecks::VerifyQueryIsReset(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject query_obj) {
+bool CoreChecks::VerifyQueryIsReset(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject query_obj) const {
     bool skip = false;
 
     auto queue_data = GetQueueState(queue);
@@ -8794,14 +9118,28 @@ bool CoreChecks::VerifyQueryIsReset(VkQueue queue, VkCommandBuffer commandBuffer
     return skip;
 }
 
-void CoreChecks::PostCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) {
+void ValidationStateTracker::PostCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot,
+                                                         VkFlags flags) {
     QueryObject query = {queryPool, slot};
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
-    RecordBeginQuery(cb_state, query);
+    RecordCmdBeginQuery(cb_state, query);
+}
+
+void CoreChecks::EnqueueVerifyBeginQuery(VkCommandBuffer command_buffer, const QueryObject &query_obj) {
+    CMD_BUFFER_STATE *cb_state = GetCBState(command_buffer);
+
+    // Enqueue the submit time validation here, ahead of the submit time state update in the StateTracker's PostCallRecord
+    cb_state->queryUpdates.emplace_back(
+        [this, cb_state, query_obj](VkQueue q) { return VerifyQueryIsReset(q, cb_state->commandBuffer, query_obj); });
+}
+
+void CoreChecks::PreCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) {
+    QueryObject query_obj = {queryPool, slot};
+    EnqueueVerifyBeginQuery(commandBuffer, query_obj);
 }
 
 bool CoreChecks::ValidateCmdEndQuery(const CMD_BUFFER_STATE *cb_state, const QueryObject &query_obj, CMD_TYPE cmd,
-                                     const char *cmd_name, const char *vuid_queue_flags, const char *vuid_active_queries) {
+                                     const char *cmd_name, const char *vuid_queue_flags, const char *vuid_active_queries) const {
     bool skip = false;
     if (!cb_state->activeQueries.count(query_obj)) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -8817,22 +9155,21 @@ bool CoreChecks::ValidateCmdEndQuery(const CMD_BUFFER_STATE *cb_state, const Que
 bool CoreChecks::PreCallValidateCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
     if (disabled.query_validation) return false;
     QueryObject query_obj = {queryPool, slot};
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     return ValidateCmdEndQuery(cb_state, query_obj, CMD_ENDQUERY, "vkCmdEndQuery()", "VUID-vkCmdEndQuery-commandBuffer-cmdpool",
                                "VUID-vkCmdEndQuery-None-01923");
 }
 
-void CoreChecks::RecordCmdEndQuery(CMD_BUFFER_STATE *cb_state, const QueryObject &query_obj) {
+void ValidationStateTracker::RecordCmdEndQuery(CMD_BUFFER_STATE *cb_state, const QueryObject &query_obj) {
     cb_state->activeQueries.erase(query_obj);
-    cb_state->queryUpdates.emplace_back([this, cb_state, query_obj](VkQueue q) {
-        return SetQueryState(q, cb_state->commandBuffer, query_obj, QUERYSTATE_AVAILABLE);
-    });
+    cb_state->queryUpdates.emplace_back(
+        [this, cb_state, query_obj](VkQueue q) { return SetQueryState(q, cb_state->commandBuffer, query_obj, QUERYSTATE_ENDED); });
     AddCommandBufferBinding(&GetQueryPoolState(query_obj.pool)->cb_bindings,
                             VulkanTypedHandle(query_obj.pool, kVulkanObjectTypeQueryPool), cb_state);
 }
 
-void CoreChecks::PostCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
+void ValidationStateTracker::PostCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
     QueryObject query_obj = {queryPool, slot};
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     RecordCmdEndQuery(cb_state, query_obj);
@@ -8841,7 +9178,7 @@ void CoreChecks::PostCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQuer
 bool CoreChecks::PreCallValidateCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
                                                   uint32_t queryCount) {
     if (disabled.query_validation) return false;
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
 
     bool skip = InsideRenderPass(cb_state, "vkCmdResetQueryPool()", "VUID-vkCmdResetQueryPool-renderpass");
     skip |= ValidateCmd(cb_state, CMD_RESETQUERYPOOL, "VkCmdResetQueryPool()");
@@ -8850,23 +9187,21 @@ bool CoreChecks::PreCallValidateCmdResetQueryPool(VkCommandBuffer commandBuffer,
     return skip;
 }
 
-void CoreChecks::PostCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
-                                                 uint32_t queryCount) {
+void ValidationStateTracker::PostCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                             uint32_t firstQuery, uint32_t queryCount) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
 
-    for (uint32_t i = 0; i < queryCount; i++) {
-        QueryObject query = {queryPool, firstQuery + i};
-        cb_state->queryUpdates.emplace_back(
-            [this, commandBuffer, query](VkQueue q) { return SetQueryState(q, commandBuffer, query, QUERYSTATE_RESET); });
-    }
+    cb_state->queryUpdates.emplace_back([this, commandBuffer, queryPool, firstQuery, queryCount](VkQueue q) {
+        return SetQueryStateMulti(q, commandBuffer, queryPool, firstQuery, queryCount, QUERYSTATE_RESET);
+    });
     AddCommandBufferBinding(&GetQueryPoolState(queryPool)->cb_bindings, VulkanTypedHandle(queryPool, kVulkanObjectTypeQueryPool),
                             cb_state);
 }
 
-QueryState CoreChecks::GetQueryState(QUEUE_STATE *queue_data, VkQueryPool queryPool, uint32_t queryIndex) {
+QueryState CoreChecks::GetQueryState(const QUEUE_STATE *queue_data, VkQueryPool queryPool, uint32_t queryIndex) const {
     QueryObject query = {queryPool, queryIndex};
 
-    const std::array<decltype(queryToStateMap) *, 2> map_list = {{&queue_data->queryToStateMap, &queryToStateMap}};
+    const std::array<const decltype(queryToStateMap) *, 2> map_list = {{&queue_data->queryToStateMap, &queryToStateMap}};
 
     for (const auto map : map_list) {
         auto query_data = map->find(query);
@@ -8877,7 +9212,7 @@ QueryState CoreChecks::GetQueryState(QUEUE_STATE *queue_data, VkQueryPool queryP
     return QUERYSTATE_UNKNOWN;
 }
 
-QueryResultType CoreChecks::GetQueryResultType(QueryState state, VkQueryResultFlags flags) {
+static QueryResultType GetQueryResultType(QueryState state, VkQueryResultFlags flags) {
     switch (state) {
         case QUERYSTATE_UNKNOWN:
             return QUERYRESULT_UNKNOWN;
@@ -8890,20 +9225,22 @@ QueryResultType CoreChecks::GetQueryResultType(QueryState state, VkQueryResultFl
             } else {
                 return QUERYRESULT_NO_DATA;
             }
-        case QUERYSTATE_AVAILABLE:
+        case QUERYSTATE_ENDED:
             if ((flags & VK_QUERY_RESULT_WAIT_BIT) || (flags & VK_QUERY_RESULT_PARTIAL_BIT) ||
                 (flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT)) {
                 return QUERYRESULT_SOME_DATA;
             } else {
                 return QUERYRESULT_MAYBE_NO_DATA;
             }
+        case QUERYSTATE_AVAILABLE:
+            return QUERYRESULT_SOME_DATA;
     }
     assert(false);
     return QUERYRESULT_UNKNOWN;
 }
 
 bool CoreChecks::ValidateQuery(VkQueue queue, CMD_BUFFER_STATE *pCB, VkQueryPool queryPool, uint32_t firstQuery,
-                               uint32_t queryCount, VkQueryResultFlags flags) {
+                               uint32_t queryCount, VkQueryResultFlags flags) const {
     bool skip = false;
     auto queue_data = GetQueueState(queue);
     if (!queue_data) return false;
@@ -8924,8 +9261,8 @@ bool CoreChecks::PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandB
                                                         uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                                         VkDeviceSize stride, VkQueryResultFlags flags) {
     if (disabled.query_validation) return false;
-    auto cb_state = GetCBState(commandBuffer);
-    auto dst_buff_state = GetBufferState(dstBuffer);
+    const auto cb_state = GetCBState(commandBuffer);
+    const auto dst_buff_state = GetBufferState(dstBuffer);
     assert(cb_state);
     assert(dst_buff_state);
     bool skip = ValidateMemoryIsBoundToBuffer(dst_buff_state, "vkCmdCopyQueryPoolResults()",
@@ -8943,17 +9280,24 @@ bool CoreChecks::PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandB
     return skip;
 }
 
-void CoreChecks::PostCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
-                                                       uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
-                                                       VkDeviceSize stride, VkQueryResultFlags flags) {
+void ValidationStateTracker::PostCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                                   uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer,
+                                                                   VkDeviceSize dstOffset, VkDeviceSize stride,
+                                                                   VkQueryResultFlags flags) {
     auto cb_state = GetCBState(commandBuffer);
     auto dst_buff_state = GetBufferState(dstBuffer);
     AddCommandBufferBindingBuffer(cb_state, dst_buff_state);
+    AddCommandBufferBinding(&GetQueryPoolState(queryPool)->cb_bindings, VulkanTypedHandle(queryPool, kVulkanObjectTypeQueryPool),
+                            cb_state);
+}
+
+void CoreChecks::PreCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                                      uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
+                                                      VkDeviceSize stride, VkQueryResultFlags flags) {
+    auto cb_state = GetCBState(commandBuffer);
     cb_state->queryUpdates.emplace_back([this, cb_state, queryPool, firstQuery, queryCount, flags](VkQueue q) {
         return ValidateQuery(q, cb_state, queryPool, firstQuery, queryCount, flags);
     });
-    AddCommandBufferBinding(&GetQueryPoolState(queryPool)->cb_bindings, VulkanTypedHandle(queryPool, kVulkanObjectTypeQueryPool),
-                            cb_state);
 }
 
 bool CoreChecks::PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
@@ -9028,7 +9372,7 @@ void CoreChecks::PostCallRecordCmdWriteTimestamp(VkCommandBuffer commandBuffer,
     cb_state->queryUpdates.emplace_back([this, commandBuffer, query](VkQueue q) {
         bool skip = false;
         skip |= VerifyQueryIsReset(q, commandBuffer, query);
-        skip |= SetQueryState(q, commandBuffer, query, QUERYSTATE_AVAILABLE);
+        skip |= SetQueryState(q, commandBuffer, query, QUERYSTATE_ENDED);
         return skip;
     });
     AddCommandBufferBinding(&GetQueryPoolState(queryPool)->cb_bindings, VulkanTypedHandle(queryPool, kVulkanObjectTypeQueryPool),
@@ -9036,24 +9380,42 @@ void CoreChecks::PostCallRecordCmdWriteTimestamp(VkCommandBuffer commandBuffer,
 }
 
 bool CoreChecks::MatchUsage(uint32_t count, const VkAttachmentReference2KHR *attachments, const VkFramebufferCreateInfo *fbci,
-                            VkImageUsageFlagBits usage_flag, const char *error_code) {
-    bool skip = false;
-
-    for (uint32_t attach = 0; attach < count; attach++) {
-        if (attachments[attach].attachment != VK_ATTACHMENT_UNUSED) {
-            // Attachment counts are verified elsewhere, but prevent an invalid access
-            if (attachments[attach].attachment < fbci->attachmentCount) {
-                const VkImageView *image_view = &fbci->pAttachments[attachments[attach].attachment];
-                auto view_state = GetImageViewState(*image_view);
-                if (view_state) {
-                    const VkImageCreateInfo *ici = &GetImageState(view_state->create_info.image)->createInfo;
-                    if (ici != nullptr) {
-                        if ((ici->usage & usage_flag) == 0) {
-                            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                            error_code,
-                                            "vkCreateFramebuffer:  Framebuffer Attachment (%d) conflicts with the image's "
-                                            "IMAGE_USAGE flags (%s).",
-                                            attachments[attach].attachment, string_VkImageUsageFlagBits(usage_flag));
+                            VkImageUsageFlagBits usage_flag, const char *error_code) const {
+    bool skip = false;
+
+    if (attachments) {
+        for (uint32_t attach = 0; attach < count; attach++) {
+            if (attachments[attach].attachment != VK_ATTACHMENT_UNUSED) {
+                // Attachment counts are verified elsewhere, but prevent an invalid access
+                if (attachments[attach].attachment < fbci->attachmentCount) {
+                    if ((fbci->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
+                        const VkImageView *image_view = &fbci->pAttachments[attachments[attach].attachment];
+                        auto view_state = GetImageViewState(*image_view);
+                        if (view_state) {
+                            const VkImageCreateInfo *ici = &GetImageState(view_state->create_info.image)->createInfo;
+                            if (ici != nullptr) {
+                                if ((ici->usage & usage_flag) == 0) {
+                                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                                    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, error_code,
+                                                    "vkCreateFramebuffer:  Framebuffer Attachment (%d) conflicts with the image's "
+                                                    "IMAGE_USAGE flags (%s).",
+                                                    attachments[attach].attachment, string_VkImageUsageFlagBits(usage_flag));
+                                }
+                            }
+                        }
+                    } else {
+                        const VkFramebufferAttachmentsCreateInfoKHR *fbaci =
+                            lvl_find_in_chain<VkFramebufferAttachmentsCreateInfoKHR>(fbci->pNext);
+                        if (fbaci != nullptr && fbaci->pAttachmentImageInfos != nullptr &&
+                            fbaci->attachmentImageInfoCount > attachments[attach].attachment) {
+                            uint32_t image_usage = fbaci->pAttachmentImageInfos[attachments[attach].attachment].usage;
+                            if ((image_usage & usage_flag) == 0) {
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, error_code,
+                                                "vkCreateFramebuffer:  Framebuffer attachment info (%d) conflicts with the image's "
+                                                "IMAGE_USAGE flags (%s).",
+                                                attachments[attach].attachment, string_VkImageUsageFlagBits(usage_flag));
+                            }
                         }
                     }
                 }
@@ -9072,9 +9434,38 @@ bool CoreChecks::MatchUsage(uint32_t count, const VkAttachmentReference2KHR *att
 // 6. fb attachments use idenity swizzle
 // 7. fb attachments used by renderPass for color/input/ds have correct usage bit set
 // 8. fb dimensions are within physical device limits
-bool CoreChecks::ValidateFramebufferCreateInfo(const VkFramebufferCreateInfo *pCreateInfo) {
+bool CoreChecks::ValidateFramebufferCreateInfo(const VkFramebufferCreateInfo *pCreateInfo) const {
     bool skip = false;
 
+    const VkFramebufferAttachmentsCreateInfoKHR *pFramebufferAttachmentsCreateInfo =
+        lvl_find_in_chain<VkFramebufferAttachmentsCreateInfoKHR>(pCreateInfo->pNext);
+    if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) != 0) {
+        if (!enabled_features.imageless_framebuffer_features.imagelessFramebuffer) {
+            skip |=
+                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        "VUID-VkFramebufferCreateInfo-flags-03189",
+                        "vkCreateFramebuffer(): VkFramebufferCreateInfo flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, "
+                        "but the imagelessFramebuffer feature is not enabled.");
+        }
+
+        if (pFramebufferAttachmentsCreateInfo == nullptr) {
+            skip |=
+                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                        "VUID-VkFramebufferCreateInfo-flags-03190",
+                        "vkCreateFramebuffer(): VkFramebufferCreateInfo flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, "
+                        "but no instance of VkFramebufferAttachmentsCreateInfoKHR is present in the pNext chain.");
+        } else {
+            if (pFramebufferAttachmentsCreateInfo->attachmentImageInfoCount != 0 &&
+                pFramebufferAttachmentsCreateInfo->attachmentImageInfoCount != pCreateInfo->attachmentCount) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                "VUID-VkFramebufferCreateInfo-flags-03191",
+                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachmentCount is %u, but "
+                                "VkFramebufferAttachmentsCreateInfoKHR attachmentImageInfoCount is %u.",
+                                pCreateInfo->attachmentCount, pFramebufferAttachmentsCreateInfo->attachmentImageInfoCount);
+            }
+        }
+    }
+
     auto rp_state = GetRenderPassState(pCreateInfo->renderPass);
     if (rp_state) {
         const VkRenderPassCreateInfo2KHR *rpci = rp_state->createInfo.ptr();
@@ -9087,42 +9478,56 @@ bool CoreChecks::ValidateFramebufferCreateInfo(const VkFramebufferCreateInfo *pC
                             report_data->FormatHandle(pCreateInfo->renderPass).c_str());
         } else {
             // attachmentCounts match, so make sure corresponding attachment details line up
-            const VkImageView *image_views = pCreateInfo->pAttachments;
-            for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
-                auto view_state = GetImageViewState(image_views[i]);
-                auto &ivci = view_state->create_info;
-                if (ivci.format != rpci->pAttachments[i].format) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-                                    HandleToUint64(pCreateInfo->renderPass), "VUID-VkFramebufferCreateInfo-pAttachments-00880",
-                                    "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has format of %s that does not "
-                                    "match the format of %s used by the corresponding attachment for %s.",
-                                    i, string_VkFormat(ivci.format), string_VkFormat(rpci->pAttachments[i].format),
-                                    report_data->FormatHandle(pCreateInfo->renderPass).c_str());
-                }
-                const VkImageCreateInfo *ici = &GetImageState(ivci.image)->createInfo;
-                if (ici->samples != rpci->pAttachments[i].samples) {
-                    skip |= log_msg(
-                        report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
-                        HandleToUint64(pCreateInfo->renderPass), "VUID-VkFramebufferCreateInfo-pAttachments-00881",
-                        "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has %s samples that do not match the %s "
-                        "samples used by the corresponding attachment for %s.",
-                        i, string_VkSampleCountFlagBits(ici->samples), string_VkSampleCountFlagBits(rpci->pAttachments[i].samples),
-                        report_data->FormatHandle(pCreateInfo->renderPass).c_str());
-                }
-                // Verify that view only has a single mip level
-                if (ivci.subresourceRange.levelCount != 1) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                    "VUID-VkFramebufferCreateInfo-pAttachments-00883",
-                                    "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has mip levelCount of %u but "
-                                    "only a single mip level (levelCount ==  1) is allowed when creating a Framebuffer.",
-                                    i, ivci.subresourceRange.levelCount);
-                }
-                const uint32_t mip_level = ivci.subresourceRange.baseMipLevel;
-                uint32_t mip_width = max(1u, ici->extent.width >> mip_level);
-                uint32_t mip_height = max(1u, ici->extent.height >> mip_level);
-                if ((ivci.subresourceRange.layerCount < pCreateInfo->layers) || (mip_width < pCreateInfo->width) ||
-                    (mip_height < pCreateInfo->height)) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+            if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
+                const VkImageView *image_views = pCreateInfo->pAttachments;
+                for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+                    auto view_state = GetImageViewState(image_views[i]);
+                    if (view_state == nullptr) {
+                        skip |=
+                            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+                                    HandleToUint64(image_views[i]), "VUID-VkFramebufferCreateInfo-flags-03188",
+                                    "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u is not a valid VkImageView.", i);
+                    } else {
+                        auto &ivci = view_state->create_info;
+                        if (ivci.format != rpci->pAttachments[i].format) {
+                            skip |= log_msg(
+                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                HandleToUint64(pCreateInfo->renderPass), "VUID-VkFramebufferCreateInfo-pAttachments-00880",
+                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has format of %s that does not "
+                                "match the format of %s used by the corresponding attachment for %s.",
+                                i, string_VkFormat(ivci.format), string_VkFormat(rpci->pAttachments[i].format),
+                                report_data->FormatHandle(pCreateInfo->renderPass).c_str());
+                        }
+                        const VkImageCreateInfo *ici = &GetImageState(ivci.image)->createInfo;
+                        if (ici->samples != rpci->pAttachments[i].samples) {
+                            skip |=
+                                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pCreateInfo->renderPass), "VUID-VkFramebufferCreateInfo-pAttachments-00881",
+                                        "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has %s samples that do not "
+                                        "match the %s "
+                                        "samples used by the corresponding attachment for %s.",
+                                        i, string_VkSampleCountFlagBits(ici->samples),
+                                        string_VkSampleCountFlagBits(rpci->pAttachments[i].samples),
+                                        report_data->FormatHandle(pCreateInfo->renderPass).c_str());
+                        }
+                        // Verify that view only has a single mip level
+                        if (ivci.subresourceRange.levelCount != 1) {
+                            skip |= log_msg(
+                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                "VUID-VkFramebufferCreateInfo-pAttachments-00883",
+                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has mip levelCount of %u but "
+                                "only a single mip level (levelCount ==  1) is allowed when creating a Framebuffer.",
+                                i, ivci.subresourceRange.levelCount);
+                        }
+                        const uint32_t mip_level = ivci.subresourceRange.baseMipLevel;
+                        uint32_t mip_width = max(1u, ici->extent.width >> mip_level);
+                        uint32_t mip_height = max(1u, ici->extent.height >> mip_level);
+                        if (!(rpci->pAttachments[i].initialLayout == VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT ||
+                              rpci->pAttachments[i].finalLayout == VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT)) {
+                            if ((ivci.subresourceRange.layerCount < pCreateInfo->layers) || (mip_width < pCreateInfo->width) ||
+                                (mip_height < pCreateInfo->height)) {
+                                skip |= log_msg(
+                                    report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                                     "VUID-VkFramebufferCreateInfo-pAttachments-00882",
                                     "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u mip level %u has dimensions "
                                     "smaller than the corresponding framebuffer dimensions. Here are the respective dimensions for "
@@ -9132,37 +9537,275 @@ bool CoreChecks::ValidateFramebufferCreateInfo(const VkFramebufferCreateInfo *pC
                                     "layerCount: %u, %u\n",
                                     i, ivci.subresourceRange.baseMipLevel, i, mip_width, pCreateInfo->width, mip_height,
                                     pCreateInfo->height, ivci.subresourceRange.layerCount, pCreateInfo->layers);
+                            }
+                        } else {
+                            if (device_extensions.vk_ext_fragment_density_map) {
+                                uint32_t ceiling_width = (uint32_t)ceil(
+                                    (float)pCreateInfo->width /
+                                    std::max((float)phys_dev_ext_props.fragment_density_map_props.maxFragmentDensityTexelSize.width,
+                                             1.0f));
+                                if (mip_width < ceiling_width) {
+                                    skip |= log_msg(
+                                        report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                        "VUID-VkFramebufferCreateInfo-pAttachments-02555",
+                                        "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u mip level %u has width "
+                                        "smaller than the corresponding the ceiling of framebuffer width / "
+                                        "maxFragmentDensityTexelSize.width "
+                                        "Here are the respective dimensions for attachment #%u, the ceiling value:\n "
+                                        "attachment #%u, framebuffer:\n"
+                                        "width: %u, the ceiling value: %u\n",
+                                        i, ivci.subresourceRange.baseMipLevel, i, i, mip_width, ceiling_width);
+                                }
+                                uint32_t ceiling_height = (uint32_t)ceil(
+                                    (float)pCreateInfo->height /
+                                    std::max(
+                                        (float)phys_dev_ext_props.fragment_density_map_props.maxFragmentDensityTexelSize.height,
+                                        1.0f));
+                                if (mip_height < ceiling_height) {
+                                    skip |= log_msg(
+                                        report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                        "VUID-VkFramebufferCreateInfo-pAttachments-02556",
+                                        "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u mip level %u has height "
+                                        "smaller than the corresponding the ceiling of framebuffer height / "
+                                        "maxFragmentDensityTexelSize.height "
+                                        "Here are the respective dimensions for attachment #%u, the ceiling value:\n "
+                                        "attachment #%u, framebuffer:\n"
+                                        "height: %u, the ceiling value: %u\n",
+                                        i, ivci.subresourceRange.baseMipLevel, i, i, mip_height, ceiling_height);
+                                }
+                            }
+                        }
+                        if (((ivci.components.r != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                             (ivci.components.r != VK_COMPONENT_SWIZZLE_R)) ||
+                            ((ivci.components.g != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                             (ivci.components.g != VK_COMPONENT_SWIZZLE_G)) ||
+                            ((ivci.components.b != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                             (ivci.components.b != VK_COMPONENT_SWIZZLE_B)) ||
+                            ((ivci.components.a != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                             (ivci.components.a != VK_COMPONENT_SWIZZLE_A))) {
+                            skip |= log_msg(
+                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                "VUID-VkFramebufferCreateInfo-pAttachments-00884",
+                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has non-identy swizzle. All "
+                                "framebuffer attachments must have been created with the identity swizzle. Here are the actual "
+                                "swizzle values:\n"
+                                "r swizzle = %s\n"
+                                "g swizzle = %s\n"
+                                "b swizzle = %s\n"
+                                "a swizzle = %s\n",
+                                i, string_VkComponentSwizzle(ivci.components.r), string_VkComponentSwizzle(ivci.components.g),
+                                string_VkComponentSwizzle(ivci.components.b), string_VkComponentSwizzle(ivci.components.a));
+                        }
+                    }
                 }
-                if (((ivci.components.r != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.r != VK_COMPONENT_SWIZZLE_R)) ||
-                    ((ivci.components.g != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.g != VK_COMPONENT_SWIZZLE_G)) ||
-                    ((ivci.components.b != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.b != VK_COMPONENT_SWIZZLE_B)) ||
-                    ((ivci.components.a != VK_COMPONENT_SWIZZLE_IDENTITY) && (ivci.components.a != VK_COMPONENT_SWIZZLE_A))) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                    "VUID-VkFramebufferCreateInfo-pAttachments-00884",
-                                    "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment #%u has non-identy swizzle. All "
-                                    "framebuffer attachments must have been created with the identity swizzle. Here are the actual "
-                                    "swizzle values:\n"
-                                    "r swizzle = %s\n"
-                                    "g swizzle = %s\n"
-                                    "b swizzle = %s\n"
-                                    "a swizzle = %s\n",
-                                    i, string_VkComponentSwizzle(ivci.components.r), string_VkComponentSwizzle(ivci.components.g),
-                                    string_VkComponentSwizzle(ivci.components.b), string_VkComponentSwizzle(ivci.components.a));
+            } else if (pFramebufferAttachmentsCreateInfo) {
+                // VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR is set
+                for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+                    auto &aii = pFramebufferAttachmentsCreateInfo->pAttachmentImageInfos[i];
+                    bool formatFound = false;
+                    for (uint32_t j = 0; j < aii.viewFormatCount; ++j) {
+                        if (aii.pViewFormats[j] == rpci->pAttachments[i].format) {
+                            formatFound = true;
+                        }
+                    }
+                    if (!formatFound) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pCreateInfo->renderPass), "VUID-VkFramebufferCreateInfo-flags-03205",
+                                        "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info #%u does not include "
+                                        "format %s used "
+                                        "by the corresponding attachment for renderPass (%s).",
+                                        i, string_VkFormat(rpci->pAttachments[i].format),
+                                        report_data->FormatHandle(pCreateInfo->renderPass).c_str());
+                    }
+
+                    const char *mismatchedLayersNoMultiviewVuid = device_extensions.vk_khr_multiview
+                                                                      ? "VUID-VkFramebufferCreateInfo-renderPass-03199"
+                                                                      : "VUID-VkFramebufferCreateInfo-flags-03200";
+                    if ((rpci->subpassCount == 0) || (rpci->pSubpasses[0].viewMask == 0)) {
+                        if (aii.layerCount < pCreateInfo->layers) {
+                            skip |=
+                                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                        mismatchedLayersNoMultiviewVuid,
+                                        "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info #%u has only #%u layers, "
+                                        "but framebuffer has #%u layers.",
+                                        i, aii.layerCount, pCreateInfo->layers);
+                        }
+                    }
+
+                    if (!device_extensions.vk_ext_fragment_density_map) {
+                        if (aii.width < pCreateInfo->width) {
+                            skip |= log_msg(
+                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                "VUID-VkFramebufferCreateInfo-flags-03192",
+                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info #%u has a width of only #%u, "
+                                "but framebuffer has a width of #%u.",
+                                i, aii.width, pCreateInfo->width);
+                        }
+
+                        if (aii.height < pCreateInfo->height) {
+                            skip |= log_msg(
+                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                "VUID-VkFramebufferCreateInfo-flags-03193",
+                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info #%u has a height of only #%u, "
+                                "but framebuffer has a height of #%u.",
+                                i, aii.height, pCreateInfo->height);
+                        }
+                    }
+                }
+
+                // Validate image usage
+                uint32_t attachment_index = VK_ATTACHMENT_UNUSED;
+                for (uint32_t i = 0; i < rpci->subpassCount; ++i) {
+                    skip |= MatchUsage(rpci->pSubpasses[i].colorAttachmentCount, rpci->pSubpasses[i].pColorAttachments, pCreateInfo,
+                                       VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-flags-03201");
+                    skip |=
+                        MatchUsage(rpci->pSubpasses[i].colorAttachmentCount, rpci->pSubpasses[i].pResolveAttachments, pCreateInfo,
+                                   VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-flags-03201");
+                    skip |= MatchUsage(1, rpci->pSubpasses[i].pDepthStencilAttachment, pCreateInfo,
+                                       VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-flags-03202");
+                    skip |= MatchUsage(rpci->pSubpasses[i].inputAttachmentCount, rpci->pSubpasses[i].pInputAttachments, pCreateInfo,
+                                       VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-flags-03204");
+
+                    const VkSubpassDescriptionDepthStencilResolveKHR *pDepthStencilResolve =
+                        lvl_find_in_chain<VkSubpassDescriptionDepthStencilResolveKHR>(rpci->pSubpasses[i].pNext);
+                    if (device_extensions.vk_khr_depth_stencil_resolve && pDepthStencilResolve != nullptr) {
+                        skip |= MatchUsage(1, pDepthStencilResolve->pDepthStencilResolveAttachment, pCreateInfo,
+                                           VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-flags-03203");
+                    }
+                }
+
+                if (device_extensions.vk_khr_multiview) {
+                    if ((rpci->subpassCount > 0) && (rpci->pSubpasses[0].viewMask != 0)) {
+                        for (uint32_t i = 0; i < rpci->subpassCount; ++i) {
+                            const VkSubpassDescriptionDepthStencilResolveKHR *pDepthStencilResolve =
+                                lvl_find_in_chain<VkSubpassDescriptionDepthStencilResolveKHR>(rpci->pSubpasses[i].pNext);
+                            uint32_t view_bits = rpci->pSubpasses[i].viewMask;
+                            uint32_t highest_view_bit = 0;
+
+                            for (int j = 0; j < 32; ++j) {
+                                if (((view_bits >> j) & 1) != 0) {
+                                    highest_view_bit = j;
+                                }
+                            }
+
+                            for (uint32_t j = 0; j < rpci->pSubpasses[i].colorAttachmentCount; ++j) {
+                                attachment_index = rpci->pSubpasses[i].pColorAttachments[j].attachment;
+                                if (attachment_index != VK_ATTACHMENT_UNUSED) {
+                                    uint32_t layer_count =
+                                        pFramebufferAttachmentsCreateInfo->pAttachmentImageInfos[attachment_index].layerCount;
+                                    if (layer_count <= highest_view_bit) {
+                                        skip |= log_msg(
+                                            report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                            HandleToUint64(pCreateInfo->renderPass),
+                                            "VUID-VkFramebufferCreateInfo-renderPass-03198",
+                                            "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info %u "
+                                            "only specifies %u layers, but the view mask for subpass %u in renderPass (%s) "
+                                            "includes layer %u, with that attachment specified as a color attachment %u.",
+                                            attachment_index, layer_count, i,
+                                            report_data->FormatHandle(pCreateInfo->renderPass).c_str(), highest_view_bit, j);
+                                    }
+                                }
+                                if (rpci->pSubpasses[i].pResolveAttachments) {
+                                    attachment_index = rpci->pSubpasses[i].pResolveAttachments[j].attachment;
+                                    if (attachment_index != VK_ATTACHMENT_UNUSED) {
+                                        uint32_t layer_count =
+                                            pFramebufferAttachmentsCreateInfo->pAttachmentImageInfos[attachment_index].layerCount;
+                                        if (layer_count <= highest_view_bit) {
+                                            skip |= log_msg(
+                                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                                VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                                HandleToUint64(pCreateInfo->renderPass),
+                                                "VUID-VkFramebufferCreateInfo-renderPass-03198",
+                                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info %u "
+                                                "only specifies %u layers, but the view mask for subpass %u in renderPass (%s) "
+                                                "includes layer %u, with that attachment specified as a resolve attachment %u.",
+                                                attachment_index, layer_count, i,
+                                                report_data->FormatHandle(pCreateInfo->renderPass).c_str(), highest_view_bit, j);
+                                        }
+                                    }
+                                }
+                            }
+
+                            for (uint32_t j = 0; j < rpci->pSubpasses[i].inputAttachmentCount; ++j) {
+                                attachment_index = rpci->pSubpasses[i].pInputAttachments[j].attachment;
+                                if (attachment_index != VK_ATTACHMENT_UNUSED) {
+                                    uint32_t layer_count =
+                                        pFramebufferAttachmentsCreateInfo->pAttachmentImageInfos[attachment_index].layerCount;
+                                    if (layer_count <= highest_view_bit) {
+                                        skip |= log_msg(
+                                            report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                            HandleToUint64(pCreateInfo->renderPass),
+                                            "VUID-VkFramebufferCreateInfo-renderPass-03198",
+                                            "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info %u "
+                                            "only specifies %u layers, but the view mask for subpass %u in renderPass (%s) "
+                                            "includes layer %u, with that attachment specified as an input attachment %u.",
+                                            attachment_index, layer_count, i,
+                                            report_data->FormatHandle(pCreateInfo->renderPass).c_str(), highest_view_bit, j);
+                                    }
+                                }
+                            }
+
+                            if (rpci->pSubpasses[i].pDepthStencilAttachment != nullptr) {
+                                attachment_index = rpci->pSubpasses[i].pDepthStencilAttachment->attachment;
+                                if (attachment_index != VK_ATTACHMENT_UNUSED) {
+                                    uint32_t layer_count =
+                                        pFramebufferAttachmentsCreateInfo->pAttachmentImageInfos[attachment_index].layerCount;
+                                    if (layer_count <= highest_view_bit) {
+                                        skip |= log_msg(
+                                            report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                            HandleToUint64(pCreateInfo->renderPass),
+                                            "VUID-VkFramebufferCreateInfo-renderPass-03198",
+                                            "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info %u "
+                                            "only specifies %u layers, but the view mask for subpass %u in renderPass (%s) "
+                                            "includes layer %u, with that attachment specified as a depth/stencil attachment.",
+                                            attachment_index, layer_count, i,
+                                            report_data->FormatHandle(pCreateInfo->renderPass).c_str(), highest_view_bit);
+                                    }
+                                }
+
+                                if (device_extensions.vk_khr_depth_stencil_resolve && pDepthStencilResolve != nullptr &&
+                                    pDepthStencilResolve->pDepthStencilResolveAttachment != nullptr) {
+                                    attachment_index = pDepthStencilResolve->pDepthStencilResolveAttachment->attachment;
+                                    if (attachment_index != VK_ATTACHMENT_UNUSED) {
+                                        uint32_t layer_count =
+                                            pFramebufferAttachmentsCreateInfo->pAttachmentImageInfos[attachment_index].layerCount;
+                                        if (layer_count <= highest_view_bit) {
+                                            skip |= log_msg(
+                                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                                VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                                HandleToUint64(pCreateInfo->renderPass),
+                                                "VUID-VkFramebufferCreateInfo-renderPass-03198",
+                                                "vkCreateFramebuffer(): VkFramebufferCreateInfo attachment info %u "
+                                                "only specifies %u layers, but the view mask for subpass %u in renderPass (%s) "
+                                                "includes layer %u, with that attachment specified as a depth/stencil resolve "
+                                                "attachment.",
+                                                attachment_index, layer_count, i,
+                                                report_data->FormatHandle(pCreateInfo->renderPass).c_str(), highest_view_bit);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
-        }
-        // Verify correct attachment usage flags
-        for (uint32_t subpass = 0; subpass < rpci->subpassCount; subpass++) {
-            // Verify input attachments:
-            skip |= MatchUsage(rpci->pSubpasses[subpass].inputAttachmentCount, rpci->pSubpasses[subpass].pInputAttachments,
-                               pCreateInfo, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-pAttachments-00879");
-            // Verify color attachments:
-            skip |= MatchUsage(rpci->pSubpasses[subpass].colorAttachmentCount, rpci->pSubpasses[subpass].pColorAttachments,
-                               pCreateInfo, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-pAttachments-00877");
-            // Verify depth/stencil attachments:
-            if (rpci->pSubpasses[subpass].pDepthStencilAttachment != nullptr) {
-                skip |= MatchUsage(1, rpci->pSubpasses[subpass].pDepthStencilAttachment, pCreateInfo,
+
+            if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
+                // Verify correct attachment usage flags
+                for (uint32_t subpass = 0; subpass < rpci->subpassCount; subpass++) {
+                    // Verify input attachments:
+                    skip |= MatchUsage(rpci->pSubpasses[subpass].inputAttachmentCount, rpci->pSubpasses[subpass].pInputAttachments,
+                                       pCreateInfo, VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT,
+                                       "VUID-VkFramebufferCreateInfo-pAttachments-00879");
+                    // Verify color attachments:
+                    skip |= MatchUsage(rpci->pSubpasses[subpass].colorAttachmentCount, rpci->pSubpasses[subpass].pColorAttachments,
+                                       pCreateInfo, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
+                                       "VUID-VkFramebufferCreateInfo-pAttachments-00877");
+                    // Verify depth/stencil attachments:
+                    skip |=
+                        MatchUsage(1, rpci->pSubpasses[subpass].pDepthStencilAttachment, pCreateInfo,
                                    VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, "VUID-VkFramebufferCreateInfo-pAttachments-02633");
+                }
             }
         }
     }
@@ -9215,19 +9858,21 @@ bool CoreChecks::PreCallValidateCreateFramebuffer(VkDevice device, const VkFrame
     return skip;
 }
 
-void CoreChecks::PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
-                                                 const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer,
-                                                 VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
+                                                             const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer,
+                                                             VkResult result) {
     if (VK_SUCCESS != result) return;
     // Shadow create info and store in map
     std::unique_ptr<FRAMEBUFFER_STATE> fb_state(
         new FRAMEBUFFER_STATE(*pFramebuffer, pCreateInfo, GetRenderPassStateSharedPtr(pCreateInfo->renderPass)));
 
-    for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
-        VkImageView view = pCreateInfo->pAttachments[i];
-        auto view_state = GetImageViewState(view);
-        if (!view_state) {
-            continue;
+    if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
+        for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
+            VkImageView view = pCreateInfo->pAttachments[i];
+            auto view_state = GetImageViewState(view);
+            if (!view_state) {
+                continue;
+            }
         }
     }
     frameBufferMap[*pFramebuffer] = std::move(fb_state);
@@ -9250,25 +9895,38 @@ static bool FindDependency(const uint32_t index, const uint32_t dependent, const
     return false;
 }
 
-bool CoreChecks::CheckDependencyExists(const uint32_t subpass, const std::vector<uint32_t> &dependent_subpasses,
-                                       const std::vector<DAGNode> &subpass_to_node, bool &skip) {
+bool CoreChecks::IsImageLayoutReadOnly(VkImageLayout layout) const {
+    if ((layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL) || (layout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) ||
+        (layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL) ||
+        (layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)) {
+        return true;
+    }
+    return false;
+}
+
+bool CoreChecks::CheckDependencyExists(const uint32_t subpass, const VkImageLayout layout,
+                                       const std::vector<SubpassLayout> &dependent_subpasses,
+                                       const std::vector<DAGNode> &subpass_to_node, bool &skip) const {
     bool result = true;
+    bool bImageLayoutReadOnly = IsImageLayoutReadOnly(layout);
     // Loop through all subpasses that share the same attachment and make sure a dependency exists
     for (uint32_t k = 0; k < dependent_subpasses.size(); ++k) {
-        if (static_cast<uint32_t>(subpass) == dependent_subpasses[k]) continue;
+        const SubpassLayout &sp = dependent_subpasses[k];
+        if (subpass == sp.index) continue;
+        if (bImageLayoutReadOnly && IsImageLayoutReadOnly(sp.layout)) continue;
+
         const DAGNode &node = subpass_to_node[subpass];
         // Check for a specified dependency between the two nodes. If one exists we are done.
-        auto prev_elem = std::find(node.prev.begin(), node.prev.end(), dependent_subpasses[k]);
-        auto next_elem = std::find(node.next.begin(), node.next.end(), dependent_subpasses[k]);
+        auto prev_elem = std::find(node.prev.begin(), node.prev.end(), sp.index);
+        auto next_elem = std::find(node.next.begin(), node.next.end(), sp.index);
         if (prev_elem == node.prev.end() && next_elem == node.next.end()) {
             // If no dependency exits an implicit dependency still might. If not, throw an error.
             std::unordered_set<uint32_t> processed_nodes;
-            if (!(FindDependency(subpass, dependent_subpasses[k], subpass_to_node, processed_nodes) ||
-                  FindDependency(dependent_subpasses[k], subpass, subpass_to_node, processed_nodes))) {
+            if (!(FindDependency(subpass, sp.index, subpass_to_node, processed_nodes) ||
+                  FindDependency(sp.index, subpass, subpass_to_node, processed_nodes))) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                                 kVUID_Core_DrawState_InvalidRenderpass,
-                                "A dependency between subpasses %d and %d must exist but one is not specified.", subpass,
-                                dependent_subpasses[k]);
+                                "A dependency between subpasses %d and %d must exist but one is not specified.", subpass, sp.index);
                 result = false;
             }
         }
@@ -9277,7 +9935,7 @@ bool CoreChecks::CheckDependencyExists(const uint32_t subpass, const std::vector
 }
 
 bool CoreChecks::CheckPreserved(const VkRenderPassCreateInfo2KHR *pCreateInfo, const int index, const uint32_t attachment,
-                                const std::vector<DAGNode> &subpass_to_node, int depth, bool &skip) {
+                                const std::vector<DAGNode> &subpass_to_node, int depth, bool &skip) const {
     const DAGNode &node = subpass_to_node[index];
     // If this node writes to the attachment return true as next nodes need to preserve the attachment.
     const VkSubpassDescription2KHR &subpass = pCreateInfo->pSubpasses[index];
@@ -9324,22 +9982,28 @@ bool IsRegionOverlapping(VkImageSubresourceRange range1, VkImageSubresourceRange
             IsRangeOverlapping(range1.baseArrayLayer, range1.layerCount, range2.baseArrayLayer, range2.layerCount));
 }
 
-bool CoreChecks::ValidateDependencies(FRAMEBUFFER_STATE const *framebuffer, RENDER_PASS_STATE const *renderPass) {
+bool CoreChecks::ValidateDependencies(FRAMEBUFFER_STATE const *framebuffer, RENDER_PASS_STATE const *renderPass) const {
     bool skip = false;
     auto const pFramebufferInfo = framebuffer->createInfo.ptr();
     auto const pCreateInfo = renderPass->createInfo.ptr();
     auto const &subpass_to_node = renderPass->subpassToNode;
-    std::vector<std::vector<uint32_t>> output_attachment_to_subpass(pCreateInfo->attachmentCount);
-    std::vector<std::vector<uint32_t>> input_attachment_to_subpass(pCreateInfo->attachmentCount);
-    std::vector<std::vector<uint32_t>> overlapping_attachments(pCreateInfo->attachmentCount);
+
+    struct Attachment {
+        std::vector<SubpassLayout> outputs;
+        std::vector<SubpassLayout> inputs;
+        std::vector<uint32_t> overlapping;
+    };
+
+    std::vector<Attachment> attachments(pCreateInfo->attachmentCount);
+
     // Find overlapping attachments
     for (uint32_t i = 0; i < pCreateInfo->attachmentCount; ++i) {
         for (uint32_t j = i + 1; j < pCreateInfo->attachmentCount; ++j) {
             VkImageView viewi = pFramebufferInfo->pAttachments[i];
             VkImageView viewj = pFramebufferInfo->pAttachments[j];
             if (viewi == viewj) {
-                overlapping_attachments[i].push_back(j);
-                overlapping_attachments[j].push_back(i);
+                attachments[i].overlapping.emplace_back(j);
+                attachments[j].overlapping.emplace_back(i);
                 continue;
             }
             auto view_state_i = GetImageViewState(viewi);
@@ -9350,8 +10014,8 @@ bool CoreChecks::ValidateDependencies(FRAMEBUFFER_STATE const *framebuffer, REND
             auto view_ci_i = view_state_i->create_info;
             auto view_ci_j = view_state_j->create_info;
             if (view_ci_i.image == view_ci_j.image && IsRegionOverlapping(view_ci_i.subresourceRange, view_ci_j.subresourceRange)) {
-                overlapping_attachments[i].push_back(j);
-                overlapping_attachments[j].push_back(i);
+                attachments[i].overlapping.emplace_back(j);
+                attachments[j].overlapping.emplace_back(i);
                 continue;
             }
             auto image_data_i = GetImageState(view_ci_i.image);
@@ -9362,8 +10026,8 @@ bool CoreChecks::ValidateDependencies(FRAMEBUFFER_STATE const *framebuffer, REND
             if (image_data_i->binding.mem == image_data_j->binding.mem &&
                 IsRangeOverlapping(image_data_i->binding.offset, image_data_i->binding.size, image_data_j->binding.offset,
                                    image_data_j->binding.size)) {
-                overlapping_attachments[i].push_back(j);
-                overlapping_attachments[j].push_back(i);
+                attachments[i].overlapping.emplace_back(j);
+                attachments[j].overlapping.emplace_back(i);
             }
         }
     }
@@ -9375,25 +10039,28 @@ bool CoreChecks::ValidateDependencies(FRAMEBUFFER_STATE const *framebuffer, REND
         for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
             uint32_t attachment = subpass.pInputAttachments[j].attachment;
             if (attachment == VK_ATTACHMENT_UNUSED) continue;
-            input_attachment_to_subpass[attachment].push_back(i);
-            for (auto overlapping_attachment : overlapping_attachments[attachment]) {
-                input_attachment_to_subpass[overlapping_attachment].push_back(i);
+            SubpassLayout sp = {i, subpass.pInputAttachments[j].layout};
+            attachments[attachment].inputs.emplace_back(sp);
+            for (auto overlapping_attachment : attachments[attachment].overlapping) {
+                attachments[overlapping_attachment].inputs.emplace_back(sp);
             }
         }
         for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
             uint32_t attachment = subpass.pColorAttachments[j].attachment;
             if (attachment == VK_ATTACHMENT_UNUSED) continue;
-            output_attachment_to_subpass[attachment].push_back(i);
-            for (auto overlapping_attachment : overlapping_attachments[attachment]) {
-                output_attachment_to_subpass[overlapping_attachment].push_back(i);
+            SubpassLayout sp = {i, subpass.pColorAttachments[j].layout};
+            attachments[attachment].outputs.emplace_back(sp);
+            for (auto overlapping_attachment : attachments[attachment].overlapping) {
+                attachments[overlapping_attachment].outputs.emplace_back(sp);
             }
             attachmentIndices.insert(attachment);
         }
         if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
             uint32_t attachment = subpass.pDepthStencilAttachment->attachment;
-            output_attachment_to_subpass[attachment].push_back(i);
-            for (auto overlapping_attachment : overlapping_attachments[attachment]) {
-                output_attachment_to_subpass[overlapping_attachment].push_back(i);
+            SubpassLayout sp = {i, subpass.pDepthStencilAttachment->layout};
+            attachments[attachment].outputs.emplace_back(sp);
+            for (auto overlapping_attachment : attachments[attachment].overlapping) {
+                attachments[overlapping_attachment].outputs.emplace_back(sp);
             }
 
             if (attachmentIndices.count(attachment)) {
@@ -9411,19 +10078,21 @@ bool CoreChecks::ValidateDependencies(FRAMEBUFFER_STATE const *framebuffer, REND
         for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
             uint32_t attachment = subpass.pInputAttachments[j].attachment;
             if (attachment == VK_ATTACHMENT_UNUSED) continue;
-            CheckDependencyExists(i, output_attachment_to_subpass[attachment], subpass_to_node, skip);
+            CheckDependencyExists(i, subpass.pInputAttachments[j].layout, attachments[attachment].outputs, subpass_to_node, skip);
         }
         // If the attachment is an output then all subpasses that use the attachment must have a dependency relationship
         for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
             uint32_t attachment = subpass.pColorAttachments[j].attachment;
             if (attachment == VK_ATTACHMENT_UNUSED) continue;
-            CheckDependencyExists(i, output_attachment_to_subpass[attachment], subpass_to_node, skip);
-            CheckDependencyExists(i, input_attachment_to_subpass[attachment], subpass_to_node, skip);
+            CheckDependencyExists(i, subpass.pColorAttachments[j].layout, attachments[attachment].outputs, subpass_to_node, skip);
+            CheckDependencyExists(i, subpass.pColorAttachments[j].layout, attachments[attachment].inputs, subpass_to_node, skip);
         }
         if (subpass.pDepthStencilAttachment && subpass.pDepthStencilAttachment->attachment != VK_ATTACHMENT_UNUSED) {
             const uint32_t &attachment = subpass.pDepthStencilAttachment->attachment;
-            CheckDependencyExists(i, output_attachment_to_subpass[attachment], subpass_to_node, skip);
-            CheckDependencyExists(i, input_attachment_to_subpass[attachment], subpass_to_node, skip);
+            CheckDependencyExists(i, subpass.pDepthStencilAttachment->layout, attachments[attachment].outputs, subpass_to_node,
+                                  skip);
+            CheckDependencyExists(i, subpass.pDepthStencilAttachment->layout, attachments[attachment].inputs, subpass_to_node,
+                                  skip);
         }
     }
     // Loop through implicit dependencies, if this pass reads make sure the attachment is preserved for all passes after it was
@@ -9437,8 +10106,8 @@ bool CoreChecks::ValidateDependencies(FRAMEBUFFER_STATE const *framebuffer, REND
     return skip;
 }
 
-void CoreChecks::RecordRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR *pCreateInfo,
-                                     RENDER_PASS_STATE *render_pass) {
+void ValidationStateTracker::RecordRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR *pCreateInfo,
+                                                 RENDER_PASS_STATE *render_pass) {
     auto &subpass_to_node = render_pass->subpassToNode;
     subpass_to_node.resize(pCreateInfo->subpassCount);
     auto &self_dependencies = render_pass->self_dependencies;
@@ -9461,77 +10130,19 @@ void CoreChecks::RecordRenderPassDAG(RenderPassCreateVersion rp_version, const V
     }
 }
 
-bool CoreChecks::ValidateRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR *pCreateInfo,
-                                       RENDER_PASS_STATE *render_pass) {
-    // Shorthand...
-    auto &subpass_to_node = render_pass->subpassToNode;
-    subpass_to_node.resize(pCreateInfo->subpassCount);
-    auto &self_dependencies = render_pass->self_dependencies;
-    self_dependencies.resize(pCreateInfo->subpassCount);
-
+bool CoreChecks::ValidateRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR *pCreateInfo) const {
     bool skip = false;
     const char *vuid;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
 
-    for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
-        subpass_to_node[i].pass = i;
-        self_dependencies[i].clear();
-    }
     for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) {
         const VkSubpassDependency2KHR &dependency = pCreateInfo->pDependencies[i];
-        VkPipelineStageFlags exclude_graphics_pipeline_stages =
-            ~(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | ExpandPipelineStageFlags(device_extensions, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT));
         VkPipelineStageFlagBits latest_src_stage = GetLogicallyLatestGraphicsPipelineStage(dependency.srcStageMask);
         VkPipelineStageFlagBits earliest_dst_stage = GetLogicallyEarliestGraphicsPipelineStage(dependency.dstStageMask);
 
-        // This VU is actually generalised  to *any* pipeline - not just graphics - but only graphics render passes are
-        // currently supported by the spec - so only that pipeline is checked here.
-        // If that is ever relaxed, this check should be extended to cover those pipelines.
-        if (dependency.srcSubpass == dependency.dstSubpass && (dependency.srcStageMask & exclude_graphics_pipeline_stages) != 0u &&
-            (dependency.dstStageMask & exclude_graphics_pipeline_stages) != 0u) {
-            vuid = use_rp2 ? "VUID-VkSubpassDependency2KHR-srcSubpass-02244" : "VUID-VkSubpassDependency-srcSubpass-01989";
-            skip |= log_msg(
-                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
-                "Dependency %u is a self-dependency, but specifies stage masks that contain stages not in the GRAPHICS pipeline.",
-                i);
-        } else if (dependency.srcSubpass != VK_SUBPASS_EXTERNAL && (dependency.srcStageMask & VK_PIPELINE_STAGE_HOST_BIT)) {
-            vuid = use_rp2 ? "VUID-VkSubpassDependency2KHR-srcSubpass-03078" : "VUID-VkSubpassDependency-srcSubpass-00858";
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
-                            "Dependency %u specifies a dependency from subpass %u, but includes HOST_BIT in the source stage mask.",
-                            i, dependency.srcSubpass);
-        } else if (dependency.dstSubpass != VK_SUBPASS_EXTERNAL && (dependency.dstStageMask & VK_PIPELINE_STAGE_HOST_BIT)) {
-            vuid = use_rp2 ? "VUID-VkSubpassDependency2KHR-dstSubpass-03079" : "VUID-VkSubpassDependency-dstSubpass-00859";
-            skip |=
-                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
-                        "Dependency %u specifies a dependency to subpass %u, but includes HOST_BIT in the destination stage mask.",
-                        i, dependency.dstSubpass);
-        }
-        // These next two VUs are actually generalised  to *any* pipeline - not just graphics - but only graphics render passes are
-        // currently supported by the spec - so only that pipeline is checked here.
-        // If that is ever relaxed, these next two checks should be extended to cover those pipelines.
-        else if (dependency.srcSubpass != VK_SUBPASS_EXTERNAL &&
-                 pCreateInfo->pSubpasses[dependency.srcSubpass].pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS &&
-                 (dependency.srcStageMask & exclude_graphics_pipeline_stages) != 0u) {
-            vuid =
-                use_rp2 ? "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054" : "VUID-VkRenderPassCreateInfo-pDependencies-00837";
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
-                            "Dependency %u specifies a source stage mask that contains stages not in the GRAPHICS pipeline as used "
-                            "by the source subpass %u.",
-                            i, dependency.srcSubpass);
-        } else if (dependency.dstSubpass != VK_SUBPASS_EXTERNAL &&
-                   pCreateInfo->pSubpasses[dependency.dstSubpass].pipelineBindPoint == VK_PIPELINE_BIND_POINT_GRAPHICS &&
-                   (dependency.dstStageMask & exclude_graphics_pipeline_stages) != 0u) {
-            vuid =
-                use_rp2 ? "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055" : "VUID-VkRenderPassCreateInfo-pDependencies-00838";
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
-                            "Dependency %u specifies a destination stage mask that contains stages not in the GRAPHICS pipeline as "
-                            "used by the destination subpass %u.",
-                            i, dependency.dstSubpass);
-        }
         // The first subpass here serves as a good proxy for "is multiview enabled" - since all view masks need to be non-zero if
         // any are, which enables multiview.
-        else if (use_rp2 && (dependency.dependencyFlags & VK_DEPENDENCY_VIEW_LOCAL_BIT) &&
-                 (pCreateInfo->pSubpasses[0].viewMask == 0)) {
+        if (use_rp2 && (dependency.dependencyFlags & VK_DEPENDENCY_VIEW_LOCAL_BIT) && (pCreateInfo->pSubpasses[0].viewMask == 0)) {
             skip |= log_msg(
                 report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                 "VUID-VkRenderPassCreateInfo2KHR-viewMask-03059",
@@ -9593,19 +10204,14 @@ bool CoreChecks::ValidateRenderPassDAG(RenderPassCreateVersion rp_version, const
                     report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
                     "Dependency %u specifies a self-dependency from logically-later stage (%s) to a logically-earlier stage (%s).",
                     i, string_VkPipelineStageFlagBits(latest_src_stage), string_VkPipelineStageFlagBits(earliest_dst_stage));
-            } else {
-                self_dependencies[dependency.srcSubpass].push_back(i);
             }
-        } else {
-            subpass_to_node[dependency.dstSubpass].prev.push_back(dependency.srcSubpass);
-            subpass_to_node[dependency.srcSubpass].next.push_back(dependency.dstSubpass);
         }
     }
     return skip;
 }
 
 bool CoreChecks::ValidateAttachmentIndex(RenderPassCreateVersion rp_version, uint32_t attachment, uint32_t attachment_count,
-                                         const char *type) {
+                                         const char *type) const {
     bool skip = false;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
     const char *const function_name = use_rp2 ? "vkCreateRenderPass2KHR()" : "vkCreateRenderPass()";
@@ -9647,7 +10253,7 @@ char const *StringAttachmentType(uint8_t type) {
 
 bool CoreChecks::AddAttachmentUse(RenderPassCreateVersion rp_version, uint32_t subpass, std::vector<uint8_t> &attachment_uses,
                                   std::vector<VkImageLayout> &attachment_layouts, uint32_t attachment, uint8_t new_use,
-                                  VkImageLayout new_layout) {
+                                  VkImageLayout new_layout) const {
     if (attachment >= attachment_uses.size()) return false; /* out of range, but already reported */
 
     bool skip = false;
@@ -9679,7 +10285,7 @@ bool CoreChecks::AddAttachmentUse(RenderPassCreateVersion rp_version, uint32_t s
 }
 
 bool CoreChecks::ValidateRenderpassAttachmentUsage(RenderPassCreateVersion rp_version,
-                                                   const VkRenderPassCreateInfo2KHR *pCreateInfo) {
+                                                   const VkRenderPassCreateInfo2KHR *pCreateInfo) const {
     bool skip = false;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
     const char *vuid;
@@ -9909,7 +10515,7 @@ static void MarkAttachmentFirstUse(RENDER_PASS_STATE *render_pass, uint32_t inde
 }
 
 bool CoreChecks::ValidateCreateRenderPass(VkDevice device, RenderPassCreateVersion rp_version,
-                                          const VkRenderPassCreateInfo2KHR *pCreateInfo, RENDER_PASS_STATE *render_pass) {
+                                          const VkRenderPassCreateInfo2KHR *pCreateInfo) const {
     bool skip = false;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
     const char *vuid;
@@ -9919,8 +10525,7 @@ bool CoreChecks::ValidateCreateRenderPass(VkDevice device, RenderPassCreateVersi
     //       ValidateLayouts.
     skip |= ValidateRenderpassAttachmentUsage(rp_version, pCreateInfo);
 
-    render_pass->renderPass = VK_NULL_HANDLE;
-    skip |= ValidateRenderPassDAG(rp_version, pCreateInfo, render_pass);
+    skip |= ValidateRenderPassDAG(rp_version, pCreateInfo);
 
     // Validate multiview correlation and view masks
     bool viewMaskZero = false;
@@ -10050,17 +10655,59 @@ bool CoreChecks::PreCallValidateCreateRenderPass(VkDevice device, const VkRender
             }
         }
     }
+    const VkRenderPassFragmentDensityMapCreateInfoEXT *pFragmentDensityMapInfo =
+        lvl_find_in_chain<VkRenderPassFragmentDensityMapCreateInfoEXT>(pCreateInfo->pNext);
+    if (pFragmentDensityMapInfo) {
+        if (pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment != VK_ATTACHMENT_UNUSED) {
+            if (pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment >= pCreateInfo->attachmentCount) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02547",
+                                "fragmentDensityMapAttachment %u must be less than attachmentCount %u of for this render pass.",
+                                pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment, pCreateInfo->attachmentCount);
+            } else {
+                if (!(pFragmentDensityMapInfo->fragmentDensityMapAttachment.layout ==
+                          VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT ||
+                      pFragmentDensityMapInfo->fragmentDensityMapAttachment.layout == VK_IMAGE_LAYOUT_GENERAL)) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02549",
+                                    "Layout of fragmentDensityMapAttachment %u' must be equal to "
+                                    "VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT, or VK_IMAGE_LAYOUT_GENERAL.",
+                                    pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment);
+                }
+                if (!(pCreateInfo->pAttachments[pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment].loadOp ==
+                          VK_ATTACHMENT_LOAD_OP_LOAD ||
+                      pCreateInfo->pAttachments[pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment].loadOp ==
+                          VK_ATTACHMENT_LOAD_OP_DONT_CARE)) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02550",
+                                    "FragmentDensityMapAttachment %u' must reference an attachment with a loadOp "
+                                    "equal to VK_ATTACHMENT_LOAD_OP_LOAD or VK_ATTACHMENT_LOAD_OP_DONT_CARE.",
+                                    pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment);
+                }
+                if (pCreateInfo->pAttachments[pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment].storeOp !=
+                    VK_ATTACHMENT_STORE_OP_DONT_CARE) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02551",
+                                    "FragmentDensityMapAttachment %u' must reference an attachment with a storeOp "
+                                    "equal to VK_ATTACHMENT_STORE_OP_DONT_CARE.",
+                                    pFragmentDensityMapInfo->fragmentDensityMapAttachment.attachment);
+                }
+            }
+        }
+    }
 
     if (!skip) {
-        auto render_pass = std::unique_ptr<RENDER_PASS_STATE>(new RENDER_PASS_STATE(pCreateInfo));
-        skip |= ValidateCreateRenderPass(device, RENDER_PASS_VERSION_1, render_pass->createInfo.ptr(), render_pass.get());
+        safe_VkRenderPassCreateInfo2KHR create_info_2;
+        ConvertVkRenderPassCreateInfoToV2KHR(pCreateInfo, &create_info_2);
+        skip |= ValidateCreateRenderPass(device, RENDER_PASS_VERSION_1, create_info_2.ptr());
     }
 
     return skip;
 }
 
-void CoreChecks::RecordCreateRenderPassState(RenderPassCreateVersion rp_version, std::shared_ptr<RENDER_PASS_STATE> &render_pass,
-                                             VkRenderPass *pRenderPass) {
+void ValidationStateTracker::RecordCreateRenderPassState(RenderPassCreateVersion rp_version,
+                                                         std::shared_ptr<RENDER_PASS_STATE> &render_pass,
+                                                         VkRenderPass *pRenderPass) {
     render_pass->renderPass = *pRenderPass;
     auto create_info = render_pass->createInfo.ptr();
 
@@ -10092,17 +10739,17 @@ void CoreChecks::RecordCreateRenderPassState(RenderPassCreateVersion rp_version,
 // Use of rvalue reference exceeds reccommended usage of rvalue refs in google style guide, but intentionally forces caller to move
 // or copy.  This is clearer than passing a pointer to shared_ptr and avoids the atomic increment/decrement of shared_ptr copy
 // construction or assignment.
-void CoreChecks::PostCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
-                                                const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass,
-                                                VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
+                                                            const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass,
+                                                            VkResult result) {
     if (VK_SUCCESS != result) return;
     auto render_pass_state = std::make_shared<RENDER_PASS_STATE>(pCreateInfo);
     RecordCreateRenderPassState(RENDER_PASS_VERSION_1, render_pass_state, pRenderPass);
 }
 
-void CoreChecks::PostCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo,
-                                                    const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass,
-                                                    VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR *pCreateInfo,
+                                                                const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass,
+                                                                VkResult result) {
     if (VK_SUCCESS != result) return;
     auto render_pass_state = std::make_shared<RENDER_PASS_STATE>(pCreateInfo);
     RecordCreateRenderPassState(RENDER_PASS_VERSION_2, render_pass_state, pRenderPass);
@@ -10244,13 +10891,13 @@ bool CoreChecks::PreCallValidateCreateRenderPass2KHR(VkDevice device, const VkRe
         skip |= ValidateDepthStencilResolve(report_data, phys_dev_ext_props.depth_stencil_resolve_props, pCreateInfo);
     }
 
-    auto render_pass = std::make_shared<RENDER_PASS_STATE>(pCreateInfo);
-    skip |= ValidateCreateRenderPass(device, RENDER_PASS_VERSION_2, render_pass->createInfo.ptr(), render_pass.get());
+    safe_VkRenderPassCreateInfo2KHR create_info_2(pCreateInfo);
+    skip |= ValidateCreateRenderPass(device, RENDER_PASS_VERSION_2, create_info_2.ptr());
 
     return skip;
 }
 
-bool CoreChecks::ValidatePrimaryCommandBuffer(const CMD_BUFFER_STATE *pCB, char const *cmd_name, const char *error_code) {
+bool CoreChecks::ValidatePrimaryCommandBuffer(const CMD_BUFFER_STATE *pCB, char const *cmd_name, const char *error_code) const {
     bool skip = false;
     if (pCB->createInfo.level != VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -10260,7 +10907,7 @@ bool CoreChecks::ValidatePrimaryCommandBuffer(const CMD_BUFFER_STATE *pCB, char
     return skip;
 }
 
-bool CoreChecks::VerifyRenderAreaBounds(const VkRenderPassBeginInfo *pRenderPassBegin) {
+bool CoreChecks::VerifyRenderAreaBounds(const VkRenderPassBeginInfo *pRenderPassBegin) const {
     bool skip = false;
     const safe_VkFramebufferCreateInfo *pFramebufferInfo = &GetFramebufferState(pRenderPassBegin->framebuffer)->createInfo;
     if (pRenderPassBegin->renderArea.offset.x < 0 ||
@@ -10278,6 +10925,178 @@ bool CoreChecks::VerifyRenderAreaBounds(const VkRenderPassBeginInfo *pRenderPass
     return skip;
 }
 
+bool CoreChecks::VerifyFramebufferAndRenderPassImageViews(const VkRenderPassBeginInfo *pRenderPassBeginInfo) const {
+    bool skip = false;
+    const VkRenderPassAttachmentBeginInfoKHR *pRenderPassAttachmentBeginInfo =
+        lvl_find_in_chain<VkRenderPassAttachmentBeginInfoKHR>(pRenderPassBeginInfo->pNext);
+
+    if (pRenderPassAttachmentBeginInfo && pRenderPassAttachmentBeginInfo->attachmentCount != 0) {
+        const safe_VkFramebufferCreateInfo *pFramebufferCreateInfo =
+            &GetFramebufferState(pRenderPassBeginInfo->framebuffer)->createInfo;
+        const VkFramebufferAttachmentsCreateInfoKHR *pFramebufferAttachmentsCreateInfo =
+            lvl_find_in_chain<VkFramebufferAttachmentsCreateInfoKHR>(pFramebufferCreateInfo->pNext);
+        if ((pFramebufferCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                            HandleToUint64(pRenderPassBeginInfo->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-03207",
+                            "VkRenderPassBeginInfo: Image views specified at render pass begin, but framebuffer not created with "
+                            "VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR");
+        } else if (pFramebufferAttachmentsCreateInfo) {
+            if (pFramebufferAttachmentsCreateInfo->attachmentImageInfoCount != pRenderPassAttachmentBeginInfo->attachmentCount) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                HandleToUint64(pRenderPassBeginInfo->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-03208",
+                                "VkRenderPassBeginInfo: %u image views specified at render pass begin, but framebuffer "
+                                "created expecting %u attachments",
+                                pRenderPassAttachmentBeginInfo->attachmentCount,
+                                pFramebufferAttachmentsCreateInfo->attachmentImageInfoCount);
+            } else {
+                const safe_VkRenderPassCreateInfo2KHR *pRenderPassCreateInfo =
+                    &GetRenderPassState(pRenderPassBeginInfo->renderPass)->createInfo;
+                for (uint32_t i = 0; i < pRenderPassAttachmentBeginInfo->attachmentCount; ++i) {
+                    const VkImageViewCreateInfo *pImageViewCreateInfo =
+                        &GetImageViewState(pRenderPassAttachmentBeginInfo->pAttachments[i])->create_info;
+                    const VkFramebufferAttachmentImageInfoKHR *pFramebufferAttachmentImageInfo =
+                        &pFramebufferAttachmentsCreateInfo->pAttachmentImageInfos[i];
+                    const VkImageCreateInfo *pImageCreateInfo = &GetImageState(pImageViewCreateInfo->image)->createInfo;
+
+                    if (pFramebufferAttachmentImageInfo->flags != pImageCreateInfo->flags) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pRenderPassBeginInfo->renderPass),
+                                        "VUID-VkRenderPassBeginInfo-framebuffer-03209",
+                                        "VkRenderPassBeginInfo: Image view #%u created from an image with flags set as 0x%X, "
+                                        "but image info #%u used to create the framebuffer had flags set as 0x%X",
+                                        i, pImageCreateInfo->flags, i, pFramebufferAttachmentImageInfo->flags);
+                    }
+
+                    if (pFramebufferAttachmentImageInfo->usage != pImageCreateInfo->usage) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pRenderPassBeginInfo->renderPass),
+                                        "VUID-VkRenderPassBeginInfo-framebuffer-03210",
+                                        "VkRenderPassBeginInfo: Image view #%u created from an image with usage set as 0x%X, "
+                                        "but image info #%u used to create the framebuffer had usage set as 0x%X",
+                                        i, pImageCreateInfo->usage, i, pFramebufferAttachmentImageInfo->usage);
+                    }
+
+                    if (pFramebufferAttachmentImageInfo->width != pImageCreateInfo->extent.width) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pRenderPassBeginInfo->renderPass),
+                                        "VUID-VkRenderPassBeginInfo-framebuffer-03211",
+                                        "VkRenderPassBeginInfo: Image view #%u created from an image with width set as %u, "
+                                        "but image info #%u used to create the framebuffer had width set as %u",
+                                        i, pImageCreateInfo->extent.width, i, pFramebufferAttachmentImageInfo->width);
+                    }
+
+                    if (pFramebufferAttachmentImageInfo->height != pImageCreateInfo->extent.height) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pRenderPassBeginInfo->renderPass),
+                                        "VUID-VkRenderPassBeginInfo-framebuffer-03212",
+                                        "VkRenderPassBeginInfo: Image view #%u created from an image with height set as %u, "
+                                        "but image info #%u used to create the framebuffer had height set as %u",
+                                        i, pImageCreateInfo->extent.height, i, pFramebufferAttachmentImageInfo->height);
+                    }
+
+                    if (pFramebufferAttachmentImageInfo->layerCount != pImageViewCreateInfo->subresourceRange.layerCount) {
+                        skip |= log_msg(
+                            report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                            HandleToUint64(pRenderPassBeginInfo->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-03213",
+                            "VkRenderPassBeginInfo: Image view #%u created with a subresource range with a layerCount of %u, "
+                            "but image info #%u used to create the framebuffer had layerCount set as %u",
+                            i, pImageViewCreateInfo->subresourceRange.layerCount, i, pFramebufferAttachmentImageInfo->layerCount);
+                    }
+
+                    const VkImageFormatListCreateInfoKHR *pImageFormatListCreateInfo =
+                        lvl_find_in_chain<VkImageFormatListCreateInfoKHR>(pImageCreateInfo->pNext);
+                    if (pImageFormatListCreateInfo) {
+                        if (pImageFormatListCreateInfo->viewFormatCount != pFramebufferAttachmentImageInfo->viewFormatCount) {
+                            skip |= log_msg(
+                                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                HandleToUint64(pRenderPassBeginInfo->renderPass), "VUID-VkRenderPassBeginInfo-framebuffer-03214",
+                                "VkRenderPassBeginInfo: Image view #%u created with an image with a viewFormatCount of %u, "
+                                "but image info #%u used to create the framebuffer had viewFormatCount set as %u",
+                                i, pImageFormatListCreateInfo->viewFormatCount, i,
+                                pFramebufferAttachmentImageInfo->viewFormatCount);
+                        }
+
+                        for (uint32_t j = 0; j < pImageFormatListCreateInfo->viewFormatCount; ++j) {
+                            bool formatFound = false;
+                            for (uint32_t k = 0; k < pFramebufferAttachmentImageInfo->viewFormatCount; ++k) {
+                                if (pImageFormatListCreateInfo->pViewFormats[j] ==
+                                    pFramebufferAttachmentImageInfo->pViewFormats[k]) {
+                                    formatFound = true;
+                                }
+                            }
+                            if (!formatFound) {
+                                skip |=
+                                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                            HandleToUint64(pRenderPassBeginInfo->renderPass),
+                                            "VUID-VkRenderPassBeginInfo-framebuffer-03215",
+                                            "VkRenderPassBeginInfo: Image view #%u created with an image including the format "
+                                            "%s in its view format list, "
+                                            "but image info #%u used to create the framebuffer does not include this format",
+                                            i, string_VkFormat(pImageFormatListCreateInfo->pViewFormats[j]), i);
+                            }
+                        }
+                    }
+
+                    if (pRenderPassCreateInfo->pAttachments[i].format != pImageViewCreateInfo->format) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pRenderPassBeginInfo->renderPass),
+                                        "VUID-VkRenderPassBeginInfo-framebuffer-03216",
+                                        "VkRenderPassBeginInfo: Image view #%u created with a format of %s, "
+                                        "but render pass attachment description #%u created with a format of %s",
+                                        i, string_VkFormat(pImageViewCreateInfo->format), i,
+                                        string_VkFormat(pRenderPassCreateInfo->pAttachments[i].format));
+                    }
+
+                    if (pRenderPassCreateInfo->pAttachments[i].samples != pImageCreateInfo->samples) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
+                                        HandleToUint64(pRenderPassBeginInfo->renderPass),
+                                        "VUID-VkRenderPassBeginInfo-framebuffer-03217",
+                                        "VkRenderPassBeginInfo: Image view #%u created with an image with %s samples, "
+                                        "but render pass attachment description #%u created with %s samples",
+                                        i, string_VkSampleCountFlagBits(pImageCreateInfo->samples), i,
+                                        string_VkSampleCountFlagBits(pRenderPassCreateInfo->pAttachments[i].samples));
+                    }
+
+                    if (pImageViewCreateInfo->subresourceRange.levelCount != 1) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+                                        HandleToUint64(pRenderPassAttachmentBeginInfo->pAttachments[i]),
+                                        "VUID-VkRenderPassAttachmentBeginInfoKHR-pAttachments-03218",
+                                        "VkRenderPassAttachmentBeginInfo: Image view #%u created with multiple (%u) mip levels.", i,
+                                        pImageViewCreateInfo->subresourceRange.levelCount);
+                    }
+
+                    if (((pImageViewCreateInfo->components.r != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                         (pImageViewCreateInfo->components.r != VK_COMPONENT_SWIZZLE_R)) ||
+                        ((pImageViewCreateInfo->components.g != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                         (pImageViewCreateInfo->components.g != VK_COMPONENT_SWIZZLE_G)) ||
+                        ((pImageViewCreateInfo->components.b != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                         (pImageViewCreateInfo->components.b != VK_COMPONENT_SWIZZLE_B)) ||
+                        ((pImageViewCreateInfo->components.a != VK_COMPONENT_SWIZZLE_IDENTITY) &&
+                         (pImageViewCreateInfo->components.a != VK_COMPONENT_SWIZZLE_A))) {
+                        skip |=
+                            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT,
+                                    HandleToUint64(pRenderPassAttachmentBeginInfo->pAttachments[i]),
+                                    "VUID-VkRenderPassAttachmentBeginInfoKHR-pAttachments-03219",
+                                    "VkRenderPassAttachmentBeginInfo: Image view #%u created with non-identity swizzle. All "
+                                    "framebuffer attachments must have been created with the identity swizzle. Here are the actual "
+                                    "swizzle values:\n"
+                                    "r swizzle = %s\n"
+                                    "g swizzle = %s\n"
+                                    "b swizzle = %s\n"
+                                    "a swizzle = %s\n",
+                                    i, string_VkComponentSwizzle(pImageViewCreateInfo->components.r),
+                                    string_VkComponentSwizzle(pImageViewCreateInfo->components.g),
+                                    string_VkComponentSwizzle(pImageViewCreateInfo->components.b),
+                                    string_VkComponentSwizzle(pImageViewCreateInfo->components.a));
+                    }
+                }
+            }
+        }
+    }
+
+    return skip;
+}
+
 // If this is a stencil format, make sure the stencil[Load|Store]Op flag is checked, while if it is a depth/color attachment the
 // [load|store]Op flag must be checked
 // TODO: The memory valid flag in DEVICE_MEMORY_STATE should probably be split to track the validity of stencil memory separately.
@@ -10293,8 +11112,8 @@ static bool FormatSpecificLoadAndStoreOpSettings(VkFormat format, T color_depth_
 }
 
 bool CoreChecks::ValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, RenderPassCreateVersion rp_version,
-                                            const VkRenderPassBeginInfo *pRenderPassBegin) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+                                            const VkRenderPassBeginInfo *pRenderPassBegin) const {
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     auto render_pass_state = pRenderPassBegin ? GetRenderPassState(pRenderPassBegin->renderPass) : nullptr;
     auto framebuffer = pRenderPassBegin ? GetFramebufferState(pRenderPassBegin->framebuffer) : nullptr;
@@ -10355,6 +11174,7 @@ bool CoreChecks::ValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, Rende
                             function_name, pRenderPassBegin->clearValueCount, clear_op_size,
                             report_data->FormatHandle(render_pass_state->renderPass).c_str(), clear_op_size, clear_op_size - 1);
         }
+        skip |= VerifyFramebufferAndRenderPassImageViews(pRenderPassBegin);
         skip |= VerifyRenderAreaBounds(pRenderPassBegin);
         skip |= VerifyFramebufferAndRenderPassLayouts(rp_version, cb_state, pRenderPassBegin,
                                                       GetFramebufferState(pRenderPassBegin->framebuffer));
@@ -10413,8 +11233,9 @@ bool CoreChecks::PreCallValidateCmdBeginRenderPass2KHR(VkCommandBuffer commandBu
     return skip;
 }
 
-void CoreChecks::RecordCmdBeginRenderPassState(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
-                                               const VkSubpassContents contents) {
+void ValidationStateTracker::RecordCmdBeginRenderPassState(VkCommandBuffer commandBuffer,
+                                                           const VkRenderPassBeginInfo *pRenderPassBegin,
+                                                           const VkSubpassContents contents) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     auto render_pass_state = pRenderPassBegin ? GetRenderPassState(pRenderPassBegin->renderPass) : nullptr;
     auto framebuffer = pRenderPassBegin ? GetFramebufferState(pRenderPassBegin->framebuffer) : nullptr;
@@ -10432,8 +11253,6 @@ void CoreChecks::RecordCmdBeginRenderPassState(VkCommandBuffer commandBuffer, co
         // Connect this RP to cmdBuffer
         AddCommandBufferBinding(&render_pass_state->cb_bindings,
                                 VulkanTypedHandle(render_pass_state->renderPass, kVulkanObjectTypeRenderPass), cb_state);
-        // transition attachments to the correct layouts for beginning of renderPass and first subpass
-        TransitionBeginRenderPassLayouts(cb_state, render_pass_state, framebuffer);
 
         auto chained_device_group_struct = lvl_find_in_chain<VkDeviceGroupRenderPassBeginInfo>(pRenderPassBegin->pNext);
         if (chained_device_group_struct) {
@@ -10444,18 +11263,43 @@ void CoreChecks::RecordCmdBeginRenderPassState(VkCommandBuffer commandBuffer, co
     }
 }
 
+void CoreChecks::RecordCmdBeginRenderPassLayouts(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
+                                                 const VkSubpassContents contents) {
+    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    auto render_pass_state = pRenderPassBegin ? GetRenderPassState(pRenderPassBegin->renderPass) : nullptr;
+    auto framebuffer = pRenderPassBegin ? GetFramebufferState(pRenderPassBegin->framebuffer) : nullptr;
+    if (render_pass_state) {
+        // transition attachments to the correct layouts for beginning of renderPass and first subpass
+        TransitionBeginRenderPassLayouts(cb_state, render_pass_state, framebuffer);
+    }
+}
+
+void ValidationStateTracker::PreCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer,
+                                                             const VkRenderPassBeginInfo *pRenderPassBegin,
+                                                             VkSubpassContents contents) {
+    RecordCmdBeginRenderPassState(commandBuffer, pRenderPassBegin, contents);
+}
+
 void CoreChecks::PreCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
                                                  VkSubpassContents contents) {
-    RecordCmdBeginRenderPassState(commandBuffer, pRenderPassBegin, contents);
+    StateTracker::PreCallRecordCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
+    RecordCmdBeginRenderPassLayouts(commandBuffer, pRenderPassBegin, contents);
+}
+
+void ValidationStateTracker::PreCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
+                                                                 const VkRenderPassBeginInfo *pRenderPassBegin,
+                                                                 const VkSubpassBeginInfoKHR *pSubpassBeginInfo) {
+    RecordCmdBeginRenderPassState(commandBuffer, pRenderPassBegin, pSubpassBeginInfo->contents);
 }
 
 void CoreChecks::PreCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo *pRenderPassBegin,
                                                      const VkSubpassBeginInfoKHR *pSubpassBeginInfo) {
-    RecordCmdBeginRenderPassState(commandBuffer, pRenderPassBegin, pSubpassBeginInfo->contents);
+    StateTracker::PreCallRecordCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
+    RecordCmdBeginRenderPassLayouts(commandBuffer, pRenderPassBegin, pSubpassBeginInfo->contents);
 }
 
-bool CoreChecks::ValidateCmdNextSubpass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+bool CoreChecks::ValidateCmdNextSubpass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer) const {
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     bool skip = false;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
@@ -10491,25 +11335,41 @@ bool CoreChecks::PreCallValidateCmdNextSubpass2KHR(VkCommandBuffer commandBuffer
     return ValidateCmdNextSubpass(RENDER_PASS_VERSION_2, commandBuffer);
 }
 
-void CoreChecks::RecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+void ValidationStateTracker::RecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     cb_state->activeSubpass++;
     cb_state->activeSubpassContents = contents;
+}
+
+void CoreChecks::RecordCmdNextSubpassLayouts(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     TransitionSubpassLayouts(cb_state, cb_state->activeRenderPass, cb_state->activeSubpass,
                              GetFramebufferState(cb_state->activeRenderPassBeginInfo.framebuffer));
 }
 
-void CoreChecks::PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+void ValidationStateTracker::PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
     RecordCmdNextSubpass(commandBuffer, contents);
 }
 
+void CoreChecks::PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
+    StateTracker::PostCallRecordCmdNextSubpass(commandBuffer, contents);
+    RecordCmdNextSubpassLayouts(commandBuffer, contents);
+}
+
+void ValidationStateTracker::PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
+                                                              const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
+                                                              const VkSubpassEndInfoKHR *pSubpassEndInfo) {
+    RecordCmdNextSubpass(commandBuffer, pSubpassBeginInfo->contents);
+}
+
 void CoreChecks::PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
                                                   const VkSubpassEndInfoKHR *pSubpassEndInfo) {
-    RecordCmdNextSubpass(commandBuffer, pSubpassBeginInfo->contents);
+    StateTracker::PostCallRecordCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo);
+    RecordCmdNextSubpassLayouts(commandBuffer, pSubpassBeginInfo->contents);
 }
 
-bool CoreChecks::ValidateCmdEndRenderPass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+bool CoreChecks::ValidateCmdEndRenderPass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer) const {
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     bool skip = false;
     const bool use_rp2 = (rp_version == RENDER_PASS_VERSION_2);
@@ -10549,21 +11409,39 @@ bool CoreChecks::PreCallValidateCmdEndRenderPass2KHR(VkCommandBuffer commandBuff
     return skip;
 }
 
-void CoreChecks::RecordCmdEndRenderPassState(VkCommandBuffer commandBuffer) {
+void ValidationStateTracker::RecordCmdEndRenderPassState(VkCommandBuffer commandBuffer) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
-    FRAMEBUFFER_STATE *framebuffer = GetFramebufferState(cb_state->activeFramebuffer);
-    TransitionFinalSubpassLayouts(cb_state, &cb_state->activeRenderPassBeginInfo, framebuffer);
     cb_state->activeRenderPass = nullptr;
     cb_state->activeSubpass = 0;
     cb_state->activeFramebuffer = VK_NULL_HANDLE;
 }
 
-void CoreChecks::PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) { RecordCmdEndRenderPassState(commandBuffer); }
+void CoreChecks::RecordCmdEndRenderPassLayouts(VkCommandBuffer commandBuffer) {
+    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    FRAMEBUFFER_STATE *framebuffer = GetFramebufferState(cb_state->activeFramebuffer);
+    TransitionFinalSubpassLayouts(cb_state, &cb_state->activeRenderPassBeginInfo, framebuffer);
+}
 
-void CoreChecks::PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) {
+void ValidationStateTracker::PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) {
     RecordCmdEndRenderPassState(commandBuffer);
 }
 
+void CoreChecks::PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+    // Record the end at the CoreLevel to ensure StateTracker cleanup doesn't step on anything we need.
+    RecordCmdEndRenderPassLayouts(commandBuffer);
+    StateTracker::PostCallRecordCmdEndRenderPass(commandBuffer);
+}
+
+void ValidationStateTracker::PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
+                                                                const VkSubpassEndInfoKHR *pSubpassEndInfo) {
+    RecordCmdEndRenderPassState(commandBuffer);
+}
+
+void CoreChecks::PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR *pSubpassEndInfo) {
+    StateTracker::PostCallRecordCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo);
+    RecordCmdEndRenderPassLayouts(commandBuffer);
+}
+
 bool CoreChecks::ValidateFramebuffer(VkCommandBuffer primaryBuffer, const CMD_BUFFER_STATE *pCB, VkCommandBuffer secondaryBuffer,
                                      const CMD_BUFFER_STATE *pSubCB, const char *caller) {
     bool skip = false;
@@ -10593,7 +11471,7 @@ bool CoreChecks::ValidateFramebuffer(VkCommandBuffer primaryBuffer, const CMD_BU
     return skip;
 }
 
-bool CoreChecks::ValidateSecondaryCommandBufferState(CMD_BUFFER_STATE *pCB, CMD_BUFFER_STATE *pSubCB) {
+bool CoreChecks::ValidateSecondaryCommandBufferState(const CMD_BUFFER_STATE *pCB, const CMD_BUFFER_STATE *pSubCB) {
     bool skip = false;
     unordered_set<int> activeTypes;
     if (!disabled.query_validation) {
@@ -10645,11 +11523,11 @@ bool CoreChecks::ValidateSecondaryCommandBufferState(CMD_BUFFER_STATE *pCB, CMD_
 
 bool CoreChecks::PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
                                                    const VkCommandBuffer *pCommandBuffers) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     bool skip = false;
-    CMD_BUFFER_STATE *sub_cb_state = NULL;
-    std::unordered_set<CMD_BUFFER_STATE *> linked_command_buffers = cb_state->linkedCommandBuffers;
+    const CMD_BUFFER_STATE *sub_cb_state = NULL;
+    std::unordered_set<const CMD_BUFFER_STATE *> linked_command_buffers;
 
     for (uint32_t i = 0; i < commandBuffersCount; i++) {
         sub_cb_state = GetCBState(pCommandBuffers[i]);
@@ -10662,7 +11540,7 @@ bool CoreChecks::PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer
                             report_data->FormatHandle(pCommandBuffers[i]).c_str(), i);
         } else if (VK_COMMAND_BUFFER_LEVEL_SECONDARY == sub_cb_state->createInfo.level) {
             if (sub_cb_state->beginInfo.pInheritanceInfo != nullptr) {
-                auto secondary_rp_state = GetRenderPassState(sub_cb_state->beginInfo.pInheritanceInfo->renderPass);
+                const auto secondary_rp_state = GetRenderPassState(sub_cb_state->beginInfo.pInheritanceInfo->renderPass);
                 if (cb_state->activeRenderPass &&
                     !(sub_cb_state->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -10708,12 +11586,31 @@ bool CoreChecks::PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer
         skip |= ValidateCommandBufferState(sub_cb_state, "vkCmdExecuteCommands()", 0,
                                            "VUID-vkCmdExecuteCommands-pCommandBuffers-00089");
         if (!(sub_cb_state->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT)) {
-            if (sub_cb_state->in_use.load() || linked_command_buffers.count(sub_cb_state)) {
+            if (sub_cb_state->in_use.load()) {
+                // TODO: Find some way to differentiate between the -00090 and -00091 conditions
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
                                 HandleToUint64(cb_state->commandBuffer), "VUID-vkCmdExecuteCommands-pCommandBuffers-00090",
-                                "Attempt to simultaneously execute %s without VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set!",
+                                "Cannot execute pending %s without VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set.",
+                                report_data->FormatHandle(sub_cb_state->commandBuffer).c_str());
+            }
+            // We use an const_cast, because one cannot query a container keyed on a non-const pointer using a const pointer
+            if (cb_state->linkedCommandBuffers.count(const_cast<CMD_BUFFER_STATE *>(sub_cb_state))) {
+                skip |= log_msg(
+                    report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    HandleToUint64(cb_state->commandBuffer), "VUID-vkCmdExecuteCommands-pCommandBuffers-00092",
+                    "Cannot execute %s without VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set if previously executed in %s",
+                    report_data->FormatHandle(sub_cb_state->commandBuffer).c_str(),
+                    report_data->FormatHandle(cb_state->commandBuffer).c_str());
+            }
+
+            const auto insert_pair = linked_command_buffers.insert(sub_cb_state);
+            if (!insert_pair.second) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                                HandleToUint64(cb_state->commandBuffer), "VUID-vkCmdExecuteCommands-pCommandBuffers-00093",
+                                "Cannot duplicate %s in pCommandBuffers without VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set.",
                                 report_data->FormatHandle(cb_state->commandBuffer).c_str());
             }
+
             if (cb_state->beginInfo.flags & VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT) {
                 // Warn that non-simultaneous secondary cmd buffer renders primary non-simultaneous
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
@@ -10772,9 +11669,8 @@ bool CoreChecks::PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer
                 }
             }
         }
-
-        linked_command_buffers.insert(sub_cb_state);
     }
+
     skip |= ValidatePrimaryCommandBuffer(cb_state, "vkCmdExecuteCommands()", "VUID-vkCmdExecuteCommands-bufferlevel");
     skip |= ValidateCmdQueueFlags(cb_state, "vkCmdExecuteCommands()",
                                   VK_QUEUE_TRANSFER_BIT | VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT,
@@ -10783,8 +11679,8 @@ bool CoreChecks::PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
-                                                 const VkCommandBuffer *pCommandBuffers) {
+void ValidationStateTracker::PreCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
+                                                             const VkCommandBuffer *pCommandBuffers) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
 
     CMD_BUFFER_STATE *sub_cb_state = NULL;
@@ -10800,6 +11696,9 @@ void CoreChecks::PreCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer,
         }
 
         // Propagate inital layout and current layout state to the primary cmd buffer
+        // NOTE: The update/population of the image_layout_map is done in CoreChecks, but for other classes derived from
+        // ValidationStateTracker these maps will be empty, so leaving the propagation in the the state tracker should be a no-op
+        // for those other classes.
         for (const auto &sub_layout_map_entry : sub_cb_state->image_layout_map) {
             const auto image = sub_layout_map_entry.first;
             const auto *image_state = GetImageState(image);
@@ -11002,7 +11901,7 @@ void CoreChecks::PostCallRecordInvalidateMappedMemoryRanges(VkDevice device, uin
 
 bool CoreChecks::PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory mem, VkDeviceSize *pCommittedMem) {
     bool skip = false;
-    auto mem_info = GetDevMemState(mem);
+    const auto mem_info = GetDevMemState(mem);
 
     if (mem_info) {
         if ((phys_dev_mem_props.memoryTypes[mem_info->alloc_info.memoryTypeIndex].propertyFlags &
@@ -11016,9 +11915,9 @@ bool CoreChecks::PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDev
     return skip;
 }
 
-bool CoreChecks::ValidateBindImageMemory(const VkBindImageMemoryInfo &bindInfo, const char *api_name) {
+bool CoreChecks::ValidateBindImageMemory(const VkBindImageMemoryInfo &bindInfo, const char *api_name) const {
     bool skip = false;
-    IMAGE_STATE *image_state = GetImageState(bindInfo.image);
+    const IMAGE_STATE *image_state = GetImageState(bindInfo.image);
     if (image_state) {
         // Track objects tied to memory
         uint64_t image_handle = HandleToUint64(bindInfo.image);
@@ -11027,7 +11926,7 @@ bool CoreChecks::ValidateBindImageMemory(const VkBindImageMemoryInfo &bindInfo,
         if (image_state->external_format_android) {
             if (image_state->memory_requirements_checked) {
                 skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
-                                kVUID_Core_DrawState_InvalidImage,
+                                kVUID_Core_BindImage_InvalidMemReqQuery,
                                 "%s: Must not call vkGetImageMemoryRequirements on %s that will be bound to an external "
                                 "Android hardware buffer.",
                                 api_name, report_data->FormatHandle(bindInfo.image).c_str());
@@ -11040,15 +11939,14 @@ bool CoreChecks::ValidateBindImageMemory(const VkBindImageMemoryInfo &bindInfo,
             // BindImageMemory but it's implied in that memory being bound must conform with VkMemoryRequirements from
             // vkGetImageMemoryRequirements()
             skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, image_handle,
-                            kVUID_Core_DrawState_InvalidImage,
+                            kVUID_Core_BindImage_NoMemReqQuery,
                             "%s: Binding memory to %s but vkGetImageMemoryRequirements() has not been called on that image.",
                             api_name, report_data->FormatHandle(bindInfo.image).c_str());
-            // Make the call for them so we can verify the state
-            DispatchGetImageMemoryRequirements(device, bindInfo.image, &image_state->requirements);
+            // Use this information fetched at CreateImage time, in validation below.
         }
 
         // Validate bound memory range information
-        auto mem_info = GetDevMemState(bindInfo.memory);
+        const auto mem_info = GetDevMemState(bindInfo.memory);
         if (mem_info) {
             skip |= ValidateInsertImageMemoryRange(bindInfo.image, mem_info, bindInfo.memoryOffset, image_state->requirements,
                                                    image_state->createInfo.tiling == VK_IMAGE_TILING_LINEAR, api_name);
@@ -11135,7 +12033,7 @@ bool CoreChecks::PreCallValidateBindImageMemory(VkDevice device, VkImage image,
     return ValidateBindImageMemory(bindInfo, "vkBindImageMemory()");
 }
 
-void CoreChecks::UpdateBindImageMemoryState(const VkBindImageMemoryInfo &bindInfo) {
+void ValidationStateTracker::UpdateBindImageMemoryState(const VkBindImageMemoryInfo &bindInfo) {
     IMAGE_STATE *image_state = GetImageState(bindInfo.image);
     if (image_state) {
         const auto swapchain_info = lvl_find_in_chain<VkBindImageMemorySwapchainInfoKHR>(bindInfo.pNext);
@@ -11157,8 +12055,8 @@ void CoreChecks::UpdateBindImageMemoryState(const VkBindImageMemoryInfo &bindInf
     }
 }
 
-void CoreChecks::PostCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset,
-                                               VkResult result) {
+void ValidationStateTracker::PostCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
+                                                           VkDeviceSize memoryOffset, VkResult result) {
     if (VK_SUCCESS != result) return;
     VkBindImageMemoryInfo bindInfo = {};
     bindInfo.sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
@@ -11190,16 +12088,16 @@ bool CoreChecks::PreCallValidateBindImageMemory2KHR(VkDevice device, uint32_t bi
     return skip;
 }
 
-void CoreChecks::PostCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR *pBindInfos,
-                                                VkResult result) {
+void ValidationStateTracker::PostCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount,
+                                                            const VkBindImageMemoryInfoKHR *pBindInfos, VkResult result) {
     if (VK_SUCCESS != result) return;
     for (uint32_t i = 0; i < bindInfoCount; i++) {
         UpdateBindImageMemoryState(pBindInfos[i]);
     }
 }
 
-void CoreChecks::PostCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
-                                                   const VkBindImageMemoryInfoKHR *pBindInfos, VkResult result) {
+void ValidationStateTracker::PostCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount,
+                                                               const VkBindImageMemoryInfoKHR *pBindInfos, VkResult result) {
     if (VK_SUCCESS != result) return;
     for (uint32_t i = 0; i < bindInfoCount; i++) {
         UpdateBindImageMemoryState(pBindInfos[i]);
@@ -11238,12 +12136,21 @@ void CoreChecks::PreCallRecordSetEvent(VkDevice device, VkEvent event) {
 
 bool CoreChecks::PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo *pBindInfo,
                                                 VkFence fence) {
+    auto queue_data = GetQueueState(queue);
     auto pFence = GetFenceState(fence);
     bool skip = ValidateFenceForSubmit(pFence);
     if (skip) {
         return true;
     }
 
+    auto queueFlags = GetPhysicalDeviceState()->queue_family_properties[queue_data->queueFamilyIndex].queueFlags;
+    if (!(queueFlags & VK_QUEUE_SPARSE_BINDING_BIT)) {
+        skip |= log_msg(
+            report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(queue),
+            "VUID-vkQueueBindSparse-queuetype",
+            "Attempting vkQueueBindSparse on a non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not set.");
+    }
+
     unordered_set<VkSemaphore> signaled_semaphores;
     unordered_set<VkSemaphore> unsignaled_semaphores;
     unordered_set<VkSemaphore> internal_semaphores;
@@ -11469,12 +12376,13 @@ void CoreChecks::PostCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoC
     }
 
     if (early_retire_seq) {
-        RetireWorkOnQueue(pQueue, early_retire_seq);
+        RetireWorkOnQueue(pQueue, early_retire_seq, true);
     }
 }
 
-void CoreChecks::PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
-                                               const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore, VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
+                                                           const VkAllocationCallbacks *pAllocator, VkSemaphore *pSemaphore,
+                                                           VkResult result) {
     if (VK_SUCCESS != result) return;
     std::unique_ptr<SEMAPHORE_STATE> semaphore_state(new SEMAPHORE_STATE{});
     semaphore_state->signaler.first = VK_NULL_HANDLE;
@@ -11628,15 +12536,15 @@ void CoreChecks::PostCallRecordGetFenceFdKHR(VkDevice device, const VkFenceGetFd
     RecordGetExternalFenceState(pGetFdInfo->fence, pGetFdInfo->handleType);
 }
 
-void CoreChecks::PostCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
-                                           const VkAllocationCallbacks *pAllocator, VkEvent *pEvent, VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
+                                                       const VkAllocationCallbacks *pAllocator, VkEvent *pEvent, VkResult result) {
     if (VK_SUCCESS != result) return;
     eventMap[*pEvent].write_in_use = 0;
     eventMap[*pEvent].stageMask = VkPipelineStageFlags(0);
 }
 
 bool CoreChecks::ValidateCreateSwapchain(const char *func_name, VkSwapchainCreateInfoKHR const *pCreateInfo,
-                                         SURFACE_STATE *surface_state, SWAPCHAIN_NODE *old_swapchain_state) {
+                                         const SURFACE_STATE *surface_state, const SWAPCHAIN_NODE *old_swapchain_state) const {
     // All physical devices and queue families are required to be able to present to any native window on Android; require the
     // application to have established support on any other platform.
     if (!instance_extensions.vk_khr_android_surface) {
@@ -11823,7 +12731,7 @@ bool CoreChecks::ValidateCreateSwapchain(const char *func_name, VkSwapchainCreat
     }
 
     std::vector<VkSurfaceFormatKHR> surface_formats;
-    auto surface_formats_ref = &surface_formats;
+    const auto *surface_formats_ref = &surface_formats;
 
     // Validate pCreateInfo values with the results of vkGetPhysicalDeviceSurfaceFormatsKHR():
     if (physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState != QUERY_DETAILS) {
@@ -11976,14 +12884,14 @@ bool CoreChecks::ValidateCreateSwapchain(const char *func_name, VkSwapchainCreat
 
 bool CoreChecks::PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
                                                    const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain) {
-    auto surface_state = GetSurfaceState(pCreateInfo->surface);
-    auto old_swapchain_state = GetSwapchainState(pCreateInfo->oldSwapchain);
+    const auto surface_state = GetSurfaceState(pCreateInfo->surface);
+    const auto old_swapchain_state = GetSwapchainState(pCreateInfo->oldSwapchain);
     return ValidateCreateSwapchain("vkCreateSwapchainKHR()", pCreateInfo, surface_state, old_swapchain_state);
 }
 
-void CoreChecks::RecordCreateSwapchainState(VkResult result, const VkSwapchainCreateInfoKHR *pCreateInfo,
-                                            VkSwapchainKHR *pSwapchain, SURFACE_STATE *surface_state,
-                                            SWAPCHAIN_NODE *old_swapchain_state) {
+void ValidationStateTracker::RecordCreateSwapchainState(VkResult result, const VkSwapchainCreateInfoKHR *pCreateInfo,
+                                                        VkSwapchainKHR *pSwapchain, SURFACE_STATE *surface_state,
+                                                        SWAPCHAIN_NODE *old_swapchain_state) {
     if (VK_SUCCESS == result) {
         auto swapchain_state = unique_ptr<SWAPCHAIN_NODE>(new SWAPCHAIN_NODE(pCreateInfo, *pSwapchain));
         if (VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR == pCreateInfo->presentMode ||
@@ -12002,21 +12910,38 @@ void CoreChecks::RecordCreateSwapchainState(VkResult result, const VkSwapchainCr
     return;
 }
 
-void CoreChecks::PostCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
-                                                  const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain,
-                                                  VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *pCreateInfo,
+                                                              const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchain,
+                                                              VkResult result) {
     auto surface_state = GetSurfaceState(pCreateInfo->surface);
     auto old_swapchain_state = GetSwapchainState(pCreateInfo->oldSwapchain);
     RecordCreateSwapchainState(result, pCreateInfo, pSwapchain, surface_state, old_swapchain_state);
 }
 
-void CoreChecks::PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
-                                                  const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                              const VkAllocationCallbacks *pAllocator) {
     if (!swapchain) return;
     auto swapchain_data = GetSwapchainState(swapchain);
     if (swapchain_data) {
-        if (swapchain_data->images.size() > 0) {
-            for (auto swapchain_image : swapchain_data->images) {
+        for (const auto &swapchain_image : swapchain_data->images) {
+            ClearMemoryObjectBindings(VulkanTypedHandle(swapchain_image, kVulkanObjectTypeImage));
+            imageMap.erase(swapchain_image);
+        }
+
+        auto surface_state = GetSurfaceState(swapchain_data->createInfo.surface);
+        if (surface_state) {
+            if (surface_state->swapchain == swapchain_data) surface_state->swapchain = nullptr;
+        }
+
+        swapchainMap.erase(swapchain);
+    }
+}
+void CoreChecks::PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
+                                                  const VkAllocationCallbacks *pAllocator) {
+    if (swapchain) {
+        auto swapchain_data = GetSwapchainState(swapchain);
+        if (swapchain_data) {
+            for (const auto &swapchain_image : swapchain_data->images) {
                 auto image_sub = imageSubresourceMap.find(swapchain_image);
                 if (image_sub != imageSubresourceMap.end()) {
                     for (auto imgsubpair : image_sub->second) {
@@ -12027,19 +12952,11 @@ void CoreChecks::PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKH
                     }
                     imageSubresourceMap.erase(image_sub);
                 }
-                ClearMemoryObjectBindings(VulkanTypedHandle(swapchain_image, kVulkanObjectTypeImage));
                 EraseQFOImageRelaseBarriers(swapchain_image);
-                imageMap.erase(swapchain_image);
             }
         }
-
-        auto surface_state = GetSurfaceState(swapchain_data->createInfo.surface);
-        if (surface_state) {
-            if (surface_state->swapchain == swapchain_data) surface_state->swapchain = nullptr;
-        }
-
-        swapchainMap.erase(swapchain);
     }
+    StateTracker::PreCallRecordDestroySwapchainKHR(device, swapchain, pAllocator);
 }
 
 bool CoreChecks::PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
@@ -12276,8 +13193,8 @@ bool CoreChecks::PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint3
     bool skip = false;
     if (pCreateInfos) {
         for (uint32_t i = 0; i < swapchainCount; i++) {
-            auto surface_state = GetSurfaceState(pCreateInfos[i].surface);
-            auto old_swapchain_state = GetSwapchainState(pCreateInfos[i].oldSwapchain);
+            const auto surface_state = GetSurfaceState(pCreateInfos[i].surface);
+            const auto old_swapchain_state = GetSwapchainState(pCreateInfos[i].oldSwapchain);
             std::stringstream func_name;
             func_name << "vkCreateSharedSwapchainsKHR[" << swapchainCount << "]()";
             skip |= ValidateCreateSwapchain(func_name.str().c_str(), &pCreateInfos[i], surface_state, old_swapchain_state);
@@ -12286,10 +13203,10 @@ bool CoreChecks::PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint3
     return skip;
 }
 
-void CoreChecks::PostCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
-                                                         const VkSwapchainCreateInfoKHR *pCreateInfos,
-                                                         const VkAllocationCallbacks *pAllocator, VkSwapchainKHR *pSwapchains,
-                                                         VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                                     const VkSwapchainCreateInfoKHR *pCreateInfos,
+                                                                     const VkAllocationCallbacks *pAllocator,
+                                                                     VkSwapchainKHR *pSwapchains, VkResult result) {
     if (pCreateInfos) {
         for (uint32_t i = 0; i < swapchainCount; i++) {
             auto surface_state = GetSurfaceState(pCreateInfos[i].surface);
@@ -12300,7 +13217,7 @@ void CoreChecks::PostCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32
 }
 
 bool CoreChecks::ValidateAcquireNextImage(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore,
-                                          VkFence fence, uint32_t *pImageIndex, const char *func_name) {
+                                          VkFence fence, uint32_t *pImageIndex, const char *func_name) const {
     bool skip = false;
     if (fence == VK_NULL_HANDLE && semaphore == VK_NULL_HANDLE) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
@@ -12322,33 +13239,35 @@ bool CoreChecks::ValidateAcquireNextImage(VkDevice device, VkSwapchainKHR swapch
         skip |= ValidateFenceForSubmit(pFence);
     }
 
-    auto swapchain_data = GetSwapchainState(swapchain);
-    if (swapchain_data && swapchain_data->retired) {
-        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-                        HandleToUint64(swapchain), "VUID-vkAcquireNextImageKHR-swapchain-01285",
-                        "%s: This swapchain has been retired. The application can still present any images it "
-                        "has acquired, but cannot acquire any more.",
-                        func_name);
-    }
-
-    auto physical_device_state = GetPhysicalDeviceState();
-    if (physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState != UNCALLED) {
-        uint64_t acquired_images = std::count_if(swapchain_data->images.begin(), swapchain_data->images.end(),
-                                                 [=](VkImage image) { return GetImageState(image)->acquired; });
-        if (acquired_images > swapchain_data->images.size() - physical_device_state->surfaceCapabilities.minImageCount) {
+    const auto swapchain_data = GetSwapchainState(swapchain);
+    if (swapchain_data) {
+        if (swapchain_data->retired) {
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-                            HandleToUint64(swapchain), kVUID_Core_DrawState_SwapchainTooManyImages,
-                            "%s: Application has already acquired the maximum number of images (0x%" PRIxLEAST64 ")", func_name,
-                            acquired_images);
+                            HandleToUint64(swapchain), "VUID-vkAcquireNextImageKHR-swapchain-01285",
+                            "%s: This swapchain has been retired. The application can still present any images it "
+                            "has acquired, but cannot acquire any more.",
+                            func_name);
         }
-    }
 
-    if (swapchain_data && swapchain_data->images.size() == 0) {
-        skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-                        HandleToUint64(swapchain), kVUID_Core_DrawState_SwapchainImagesNotFound,
-                        "%s: No images found to acquire from. Application probably did not call "
-                        "vkGetSwapchainImagesKHR after swapchain creation.",
-                        func_name);
+        auto physical_device_state = GetPhysicalDeviceState();
+        if (physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState != UNCALLED) {
+            uint64_t acquired_images = std::count_if(swapchain_data->images.begin(), swapchain_data->images.end(),
+                                                     [=](VkImage image) { return GetImageState(image)->acquired; });
+            if (acquired_images > swapchain_data->images.size() - physical_device_state->surfaceCapabilities.minImageCount) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+                                HandleToUint64(swapchain), kVUID_Core_DrawState_SwapchainTooManyImages,
+                                "%s: Application has already acquired the maximum number of images (0x%" PRIxLEAST64 ")", func_name,
+                                acquired_images);
+            }
+        }
+
+        if (swapchain_data->images.size() == 0) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+                            HandleToUint64(swapchain), kVUID_Core_DrawState_SwapchainImagesNotFound,
+                            "%s: No images found to acquire from. Application probably did not call "
+                            "vkGetSwapchainImagesKHR after swapchain creation.",
+                            func_name);
+        }
     }
     return skip;
 }
@@ -12371,8 +13290,8 @@ bool CoreChecks::PreCallValidateAcquireNextImage2KHR(VkDevice device, const VkAc
     return skip;
 }
 
-void CoreChecks::RecordAcquireNextImageState(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore,
-                                             VkFence fence, uint32_t *pImageIndex) {
+void ValidationStateTracker::RecordAcquireNextImageState(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
+                                                         VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex) {
     auto pFence = GetFenceState(fence);
     if (pFence && pFence->scope == kSyncScopeInternal) {
         // Treat as inflight since it is valid to wait on this fence, even in cases where it is technically a temporary
@@ -12401,21 +13320,22 @@ void CoreChecks::RecordAcquireNextImageState(VkDevice device, VkSwapchainKHR swa
     }
 }
 
-void CoreChecks::PostCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
-                                                   VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex, VkResult result) {
+void ValidationStateTracker::PostCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout,
+                                                               VkSemaphore semaphore, VkFence fence, uint32_t *pImageIndex,
+                                                               VkResult result) {
     if ((VK_SUCCESS != result) && (VK_SUBOPTIMAL_KHR != result)) return;
     RecordAcquireNextImageState(device, swapchain, timeout, semaphore, fence, pImageIndex);
 }
 
-void CoreChecks::PostCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo,
-                                                    uint32_t *pImageIndex, VkResult result) {
+void ValidationStateTracker::PostCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo,
+                                                                uint32_t *pImageIndex, VkResult result) {
     if ((VK_SUCCESS != result) && (VK_SUBOPTIMAL_KHR != result)) return;
     RecordAcquireNextImageState(device, pAcquireInfo->swapchain, pAcquireInfo->timeout, pAcquireInfo->semaphore,
                                 pAcquireInfo->fence, pImageIndex);
 }
 
-void CoreChecks::PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
-                                                        VkPhysicalDevice *pPhysicalDevices, VkResult result) {
+void ValidationStateTracker::PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
+                                                                    VkPhysicalDevice *pPhysicalDevices, VkResult result) {
     if ((NULL != pPhysicalDevices) && ((result == VK_SUCCESS || result == VK_INCOMPLETE))) {
         for (uint32_t i = 0; i < *pPhysicalDeviceCount; i++) {
             auto &phys_device_state = physical_device_map[pPhysicalDevices[i]];
@@ -12427,7 +13347,8 @@ void CoreChecks::PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uin
 }
 
 // Common function to handle validation for GetPhysicalDeviceQueueFamilyProperties & 2KHR version
-static bool ValidateCommonGetPhysicalDeviceQueueFamilyProperties(debug_report_data *report_data, PHYSICAL_DEVICE_STATE *pd_state,
+static bool ValidateCommonGetPhysicalDeviceQueueFamilyProperties(debug_report_data *report_data,
+                                                                 const PHYSICAL_DEVICE_STATE *pd_state,
                                                                  uint32_t requested_queue_family_property_count, bool qfp_null,
                                                                  const char *caller_name) {
     bool skip = false;
@@ -12451,7 +13372,6 @@ static bool ValidateCommonGetPhysicalDeviceQueueFamilyProperties(debug_report_da
                 "previously obtained by calling %s with NULL pQueueFamilyProperties.",
                 caller_name, requested_queue_family_property_count, pd_state->queue_family_known_count, caller_name, caller_name);
         }
-        pd_state->vkGetPhysicalDeviceQueueFamilyPropertiesState = QUERY_DETAILS;
     }
 
     return skip;
@@ -12460,7 +13380,7 @@ static bool ValidateCommonGetPhysicalDeviceQueueFamilyProperties(debug_report_da
 bool CoreChecks::PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
                                                                        uint32_t *pQueueFamilyPropertyCount,
                                                                        VkQueueFamilyProperties *pQueueFamilyProperties) {
-    auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
+    const auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     assert(physical_device_state);
     return ValidateCommonGetPhysicalDeviceQueueFamilyProperties(report_data, physical_device_state, *pQueueFamilyPropertyCount,
                                                                 (nullptr == pQueueFamilyProperties),
@@ -12470,7 +13390,7 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysica
 bool CoreChecks::PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
                                                                         uint32_t *pQueueFamilyPropertyCount,
                                                                         VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
-    auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
+    const auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     assert(physical_device_state);
     return ValidateCommonGetPhysicalDeviceQueueFamilyProperties(report_data, physical_device_state, *pQueueFamilyPropertyCount,
                                                                 (nullptr == pQueueFamilyProperties),
@@ -12505,9 +13425,9 @@ static void StateUpdateCommonGetPhysicalDeviceQueueFamilyProperties(PHYSICAL_DEV
     }
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
-                                                                      uint32_t *pQueueFamilyPropertyCount,
-                                                                      VkQueueFamilyProperties *pQueueFamilyProperties) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
+                                                                                  uint32_t *pQueueFamilyPropertyCount,
+                                                                                  VkQueueFamilyProperties *pQueueFamilyProperties) {
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     assert(physical_device_state);
     VkQueueFamilyProperties2KHR *pqfp = nullptr;
@@ -12524,18 +13444,16 @@ void CoreChecks::PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysical
     StateUpdateCommonGetPhysicalDeviceQueueFamilyProperties(physical_device_state, *pQueueFamilyPropertyCount, pqfp);
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
-                                                                       uint32_t *pQueueFamilyPropertyCount,
-                                                                       VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(
+    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     assert(physical_device_state);
     StateUpdateCommonGetPhysicalDeviceQueueFamilyProperties(physical_device_state, *pQueueFamilyPropertyCount,
                                                             pQueueFamilyProperties);
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                          uint32_t *pQueueFamilyPropertyCount,
-                                                                          VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(
+    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     assert(physical_device_state);
     StateUpdateCommonGetPhysicalDeviceQueueFamilyProperties(physical_device_state, *pQueueFamilyPropertyCount,
@@ -12544,7 +13462,7 @@ void CoreChecks::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhys
 
 bool CoreChecks::PreCallValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
                                                   const VkAllocationCallbacks *pAllocator) {
-    auto surface_state = GetSurfaceState(surface);
+    const auto surface_state = GetSurfaceState(surface);
     bool skip = false;
     if ((surface_state) && (surface_state->swapchain)) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT,
@@ -12554,53 +13472,57 @@ bool CoreChecks::PreCallValidateDestroySurfaceKHR(VkInstance instance, VkSurface
     return skip;
 }
 
-void CoreChecks::PreCallRecordValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
-                                                        const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PreCallRecordDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface,
+                                                            const VkAllocationCallbacks *pAllocator) {
     surface_map.erase(surface);
 }
 
-void CoreChecks::RecordVulkanSurface(VkSurfaceKHR *pSurface) {
+void ValidationStateTracker::RecordVulkanSurface(VkSurfaceKHR *pSurface) {
     surface_map[*pSurface] = std::unique_ptr<SURFACE_STATE>(new SURFACE_STATE{*pSurface});
 }
 
-void CoreChecks::PostCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
-                                                            const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                            VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance,
+                                                                        const VkDisplaySurfaceCreateInfoKHR *pCreateInfo,
+                                                                        const VkAllocationCallbacks *pAllocator,
+                                                                        VkSurfaceKHR *pSurface, VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
-void CoreChecks::PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
-                                                       const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                       VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance,
+                                                                   const VkAndroidSurfaceCreateInfoKHR *pCreateInfo,
+                                                                   const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
+                                                                   VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
 
 #ifdef VK_USE_PLATFORM_IOS_MVK
-void CoreChecks::PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo,
-                                                   const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                   VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
+                                                               VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
 #endif  // VK_USE_PLATFORM_IOS_MVK
 
 #ifdef VK_USE_PLATFORM_MACOS_MVK
-void CoreChecks::PostCallRecordCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK *pCreateInfo,
-                                                     const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                     VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateMacOSSurfaceMVK(VkInstance instance,
+                                                                 const VkMacOSSurfaceCreateInfoMVK *pCreateInfo,
+                                                                 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
+                                                                 VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
 #endif  // VK_USE_PLATFORM_MACOS_MVK
 
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
-void CoreChecks::PostCallRecordCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
-                                                       const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                       VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateWaylandSurfaceKHR(VkInstance instance,
+                                                                   const VkWaylandSurfaceCreateInfoKHR *pCreateInfo,
+                                                                   const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
+                                                                   VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
@@ -12616,9 +13538,10 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(V
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
-void CoreChecks::PostCallRecordCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
-                                                     const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                     VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateWin32SurfaceKHR(VkInstance instance,
+                                                                 const VkWin32SurfaceCreateInfoKHR *pCreateInfo,
+                                                                 const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
+                                                                 VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
@@ -12633,9 +13556,9 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(VkP
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 
 #ifdef VK_USE_PLATFORM_XCB_KHR
-void CoreChecks::PostCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
-                                                   const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                   VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR *pCreateInfo,
+                                                               const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
+                                                               VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
@@ -12651,9 +13574,9 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(VkPhy
 #endif  // VK_USE_PLATFORM_XCB_KHR
 
 #ifdef VK_USE_PLATFORM_XLIB_KHR
-void CoreChecks::PostCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
-                                                    const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
-                                                    VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR *pCreateInfo,
+                                                                const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface,
+                                                                VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordVulkanSurface(pSurface);
 }
@@ -12668,28 +13591,29 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(VkPh
 }
 #endif  // VK_USE_PLATFORM_XLIB_KHR
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                       VkSurfaceCapabilitiesKHR *pSurfaceCapabilities,
-                                                                       VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                   VkSurfaceKHR surface,
+                                                                                   VkSurfaceCapabilitiesKHR *pSurfaceCapabilities,
+                                                                                   VkResult result) {
     if (VK_SUCCESS != result) return;
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS;
     physical_device_state->surfaceCapabilities = *pSurfaceCapabilities;
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
-                                                                        const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-                                                                        VkSurfaceCapabilities2KHR *pSurfaceCapabilities,
-                                                                        VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(
+    VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
+    VkSurfaceCapabilities2KHR *pSurfaceCapabilities, VkResult result) {
     if (VK_SUCCESS != result) return;
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS;
     physical_device_state->surfaceCapabilities = pSurfaceCapabilities->surfaceCapabilities;
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                        VkSurfaceCapabilities2EXT *pSurfaceCapabilities,
-                                                                        VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice,
+                                                                                    VkSurfaceKHR surface,
+                                                                                    VkSurfaceCapabilities2EXT *pSurfaceCapabilities,
+                                                                                    VkResult result) {
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     physical_device_state->vkGetPhysicalDeviceSurfaceCapabilitiesKHRState = QUERY_DETAILS;
     physical_device_state->surfaceCapabilities.minImageCount = pSurfaceCapabilities->minImageCount;
@@ -12712,16 +13636,19 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDev
                                     "vkGetPhysicalDeviceSurfaceSupportKHR", "queueFamilyIndex");
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-                                                                  VkSurfaceKHR surface, VkBool32 *pSupported, VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice,
+                                                                              uint32_t queueFamilyIndex, VkSurfaceKHR surface,
+                                                                              VkBool32 *pSupported, VkResult result) {
     if (VK_SUCCESS != result) return;
     auto surface_state = GetSurfaceState(surface);
     surface_state->gpu_queue_support[{physicalDevice, queueFamilyIndex}] = (*pSupported == VK_TRUE);
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                       uint32_t *pPresentModeCount, VkPresentModeKHR *pPresentModes,
-                                                                       VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice,
+                                                                                   VkSurfaceKHR surface,
+                                                                                   uint32_t *pPresentModeCount,
+                                                                                   VkPresentModeKHR *pPresentModes,
+                                                                                   VkResult result) {
     if ((VK_SUCCESS != result) && (VK_INCOMPLETE != result)) return;
 
     // TODO: This isn't quite right -- available modes may differ by surface AND physical device.
@@ -12745,8 +13672,8 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDev
                                                                    uint32_t *pSurfaceFormatCount,
                                                                    VkSurfaceFormatKHR *pSurfaceFormats) {
     if (!pSurfaceFormats) return false;
-    auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
-    auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState;
+    const auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
+    const auto &call_state = physical_device_state->vkGetPhysicalDeviceSurfaceFormatsKHRState;
     bool skip = false;
     switch (call_state) {
         case UNCALLED:
@@ -12772,9 +13699,10 @@ bool CoreChecks::PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDev
     return skip;
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                  uint32_t *pSurfaceFormatCount,
-                                                                  VkSurfaceFormatKHR *pSurfaceFormats, VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                              uint32_t *pSurfaceFormatCount,
+                                                                              VkSurfaceFormatKHR *pSurfaceFormats,
+                                                                              VkResult result) {
     if ((VK_SUCCESS != result) && (VK_INCOMPLETE != result)) return;
 
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
@@ -12793,10 +13721,11 @@ void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevi
     }
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
-                                                                   const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
-                                                                   uint32_t *pSurfaceFormatCount,
-                                                                   VkSurfaceFormat2KHR *pSurfaceFormats, VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
+                                                                               const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
+                                                                               uint32_t *pSurfaceFormatCount,
+                                                                               VkSurfaceFormat2KHR *pSurfaceFormats,
+                                                                               VkResult result) {
     if ((VK_SUCCESS != result) && (VK_INCOMPLETE != result)) return;
 
     auto physicalDeviceState = GetPhysicalDeviceState(physicalDevice);
@@ -12817,15 +13746,17 @@ void CoreChecks::PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDev
     }
 }
 
-void CoreChecks::PreCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) {
+void ValidationStateTracker::PreCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+                                                                     const VkDebugUtilsLabelEXT *pLabelInfo) {
     BeginCmdDebugUtilsLabel(report_data, commandBuffer, pLabelInfo);
 }
 
-void CoreChecks::PostCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
+void ValidationStateTracker::PostCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) {
     EndCmdDebugUtilsLabel(report_data, commandBuffer);
 }
 
-void CoreChecks::PreCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT *pLabelInfo) {
+void ValidationStateTracker::PreCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer,
+                                                                      const VkDebugUtilsLabelEXT *pLabelInfo) {
     InsertCmdDebugUtilsLabel(report_data, commandBuffer, pLabelInfo);
 
     // Squirrel away an easily accessible copy.
@@ -13119,8 +14050,8 @@ void CoreChecks::PreCallRecordCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffe
     }
 }
 
-void CoreChecks::RecordGetPhysicalDeviceDisplayPlanePropertiesState(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-                                                                    void *pProperties) {
+void ValidationStateTracker::RecordGetPhysicalDeviceDisplayPlanePropertiesState(VkPhysicalDevice physicalDevice,
+                                                                                uint32_t *pPropertyCount, void *pProperties) {
     auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     if (*pPropertyCount) {
         if (physical_device_state->vkGetPhysicalDeviceDisplayPlanePropertiesKHRState < QUERY_COUNT) {
@@ -13135,25 +14066,26 @@ void CoreChecks::RecordGetPhysicalDeviceDisplayPlanePropertiesState(VkPhysicalDe
     }
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount,
-                                                                          VkDisplayPlanePropertiesKHR *pProperties,
-                                                                          VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice,
+                                                                                      uint32_t *pPropertyCount,
+                                                                                      VkDisplayPlanePropertiesKHR *pProperties,
+                                                                                      VkResult result) {
     if ((VK_SUCCESS != result) && (VK_INCOMPLETE != result)) return;
     RecordGetPhysicalDeviceDisplayPlanePropertiesState(physicalDevice, pPropertyCount, pProperties);
 }
 
-void CoreChecks::PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                           uint32_t *pPropertyCount,
-                                                                           VkDisplayPlaneProperties2KHR *pProperties,
-                                                                           VkResult result) {
+void ValidationStateTracker::PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                                       uint32_t *pPropertyCount,
+                                                                                       VkDisplayPlaneProperties2KHR *pProperties,
+                                                                                       VkResult result) {
     if ((VK_SUCCESS != result) && (VK_INCOMPLETE != result)) return;
     RecordGetPhysicalDeviceDisplayPlanePropertiesState(physicalDevice, pPropertyCount, pProperties);
 }
 
 bool CoreChecks::ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
-                                                                         const char *api_name) {
+                                                                         const char *api_name) const {
     bool skip = false;
-    auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
+    const auto physical_device_state = GetPhysicalDeviceState(physicalDevice);
     if (physical_device_state->vkGetPhysicalDeviceDisplayPlanePropertiesKHRState == UNCALLED) {
         skip |= log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
                         HandleToUint64(physicalDevice), kVUID_Core_Swapchain_GetSupportedDisplaysWithoutQuery,
@@ -13199,13 +14131,13 @@ bool CoreChecks::PreCallValidateGetDisplayPlaneCapabilities2KHR(VkPhysicalDevice
 
 bool CoreChecks::PreCallValidateCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer,
                                                        const VkDebugMarkerMarkerInfoEXT *pMarkerInfo) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     return ValidateCmd(cb_state, CMD_DEBUGMARKERBEGINEXT, "vkCmdDebugMarkerBeginEXT()");
 }
 
 bool CoreChecks::PreCallValidateCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) {
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     return ValidateCmd(cb_state, CMD_DEBUGMARKERENDEXT, "vkCmdDebugMarkerEndEXT()");
 }
@@ -13244,25 +14176,31 @@ bool CoreChecks::PreCallValidateCmdBeginQueryIndexedEXT(VkCommandBuffer commandB
     return skip;
 }
 
-void CoreChecks::PostCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
-                                                       VkQueryControlFlags flags, uint32_t index) {
+void ValidationStateTracker::PostCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                                   uint32_t query, VkQueryControlFlags flags, uint32_t index) {
     QueryObject query_obj = {queryPool, query, index};
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
-    RecordBeginQuery(cb_state, query_obj);
+    RecordCmdBeginQuery(cb_state, query_obj);
+}
+
+void CoreChecks::PreCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                                      VkQueryControlFlags flags, uint32_t index) {
+    QueryObject query_obj = {queryPool, query, index};
+    EnqueueVerifyBeginQuery(commandBuffer, query_obj);
 }
 
 bool CoreChecks::PreCallValidateCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
                                                       uint32_t index) {
     if (disabled.query_validation) return false;
     QueryObject query_obj = {queryPool, query, index};
-    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     assert(cb_state);
     return ValidateCmdEndQuery(cb_state, query_obj, CMD_ENDQUERYINDEXEDEXT, "vkCmdEndQueryIndexedEXT()",
                                "VUID-vkCmdEndQueryIndexedEXT-commandBuffer-cmdpool", "VUID-vkCmdEndQueryIndexedEXT-None-02342");
 }
 
-void CoreChecks::PostCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
-                                                     uint32_t index) {
+void ValidationStateTracker::PostCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
+                                                                 uint32_t query, uint32_t index) {
     QueryObject query_obj = {queryPool, query, index};
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     RecordCmdEndQuery(cb_state, query_obj);
@@ -13283,7 +14221,7 @@ bool CoreChecks::PreCallValidateCmdSetSampleLocationsEXT(VkCommandBuffer command
 }
 
 bool CoreChecks::ValidateCreateSamplerYcbcrConversion(const char *func_name,
-                                                      const VkSamplerYcbcrConversionCreateInfo *create_info) {
+                                                      const VkSamplerYcbcrConversionCreateInfo *create_info) const {
     bool skip = false;
     if (device_extensions.vk_android_external_memory_android_hardware_buffer) {
         skip |= ValidateCreateSamplerYcbcrConversionANDROID(create_info);
@@ -13310,38 +14248,42 @@ bool CoreChecks::PreCallValidateCreateSamplerYcbcrConversionKHR(VkDevice device,
     return ValidateCreateSamplerYcbcrConversion("vkCreateSamplerYcbcrConversionKHR()", pCreateInfo);
 }
 
-void CoreChecks::RecordCreateSamplerYcbcrConversionState(const VkSamplerYcbcrConversionCreateInfo *create_info,
-                                                         VkSamplerYcbcrConversion ycbcr_conversion) {
+void ValidationStateTracker::RecordCreateSamplerYcbcrConversionState(const VkSamplerYcbcrConversionCreateInfo *create_info,
+                                                                     VkSamplerYcbcrConversion ycbcr_conversion) {
     if (device_extensions.vk_android_external_memory_android_hardware_buffer) {
         RecordCreateSamplerYcbcrConversionANDROID(create_info, ycbcr_conversion);
     }
 }
 
-void CoreChecks::PostCallRecordCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
-                                                            const VkAllocationCallbacks *pAllocator,
-                                                            VkSamplerYcbcrConversion *pYcbcrConversion, VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateSamplerYcbcrConversion(VkDevice device,
+                                                                        const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
+                                                                        const VkAllocationCallbacks *pAllocator,
+                                                                        VkSamplerYcbcrConversion *pYcbcrConversion,
+                                                                        VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordCreateSamplerYcbcrConversionState(pCreateInfo, *pYcbcrConversion);
 }
 
-void CoreChecks::PostCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device,
-                                                               const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
-                                                               const VkAllocationCallbacks *pAllocator,
-                                                               VkSamplerYcbcrConversion *pYcbcrConversion, VkResult result) {
+void ValidationStateTracker::PostCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device,
+                                                                           const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
+                                                                           const VkAllocationCallbacks *pAllocator,
+                                                                           VkSamplerYcbcrConversion *pYcbcrConversion,
+                                                                           VkResult result) {
     if (VK_SUCCESS != result) return;
     RecordCreateSamplerYcbcrConversionState(pCreateInfo, *pYcbcrConversion);
 }
 
-void CoreChecks::PostCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-                                                             const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PostCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+                                                                         const VkAllocationCallbacks *pAllocator) {
     if (!ycbcrConversion) return;
     if (device_extensions.vk_android_external_memory_android_hardware_buffer) {
         RecordDestroySamplerYcbcrConversionANDROID(ycbcrConversion);
     }
 }
 
-void CoreChecks::PostCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-                                                                const VkAllocationCallbacks *pAllocator) {
+void ValidationStateTracker::PostCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device,
+                                                                            VkSamplerYcbcrConversion ycbcrConversion,
+                                                                            const VkAllocationCallbacks *pAllocator) {
     if (!ycbcrConversion) return;
     if (device_extensions.vk_android_external_memory_android_hardware_buffer) {
         RecordDestroySamplerYcbcrConversionANDROID(ycbcrConversion);
@@ -13364,7 +14306,7 @@ bool CoreChecks::PreCallValidateGetBufferDeviceAddressEXT(VkDevice device, const
                         "bufferDeviceAddressMultiDevice feature must: be enabled.");
     }
 
-    auto buffer_state = GetBufferState(pInfo->buffer);
+    const auto buffer_state = GetBufferState(pInfo->buffer);
     if (buffer_state) {
         if (!(buffer_state->createInfo.flags & VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT)) {
             skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkGetBufferDeviceAddressEXT()",
@@ -13380,7 +14322,7 @@ bool CoreChecks::PreCallValidateGetBufferDeviceAddressEXT(VkDevice device, const
 }
 
 bool CoreChecks::ValidateQueryRange(VkDevice device, VkQueryPool queryPool, uint32_t totalCount, uint32_t firstQuery,
-                                    uint32_t queryCount, const char *vuid_badfirst, const char *vuid_badrange) {
+                                    uint32_t queryCount, const char *vuid_badfirst, const char *vuid_badrange) const {
     bool skip = false;
 
     if (firstQuery >= totalCount) {
@@ -13409,26 +14351,27 @@ bool CoreChecks::PreCallValidateResetQueryPoolEXT(VkDevice device, VkQueryPool q
                         "VUID-vkResetQueryPoolEXT-None-02665", "Host query reset not enabled for device");
     }
 
-    auto query_pool_it = queryPoolMap.find(queryPool);
-    if (query_pool_it != queryPoolMap.end()) {
-        skip |= ValidateQueryRange(device, queryPool, query_pool_it->second->createInfo.queryCount, firstQuery, queryCount,
+    const auto query_pool_state = GetQueryPoolState(queryPool);
+    if (query_pool_state) {
+        skip |= ValidateQueryRange(device, queryPool, query_pool_state->createInfo.queryCount, firstQuery, queryCount,
                                    "VUID-vkResetQueryPoolEXT-firstQuery-02666", "VUID-vkResetQueryPoolEXT-firstQuery-02667");
     }
 
     return skip;
 }
 
-void CoreChecks::PostCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {
+void ValidationStateTracker::PostCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery,
+                                                             uint32_t queryCount) {
     // Do nothing if the feature is not enabled.
     if (!enabled_features.host_query_reset_features.hostQueryReset) return;
 
     // Do nothing if the query pool has been destroyed.
-    auto query_pool_it = queryPoolMap.find(queryPool);
-    if (query_pool_it == queryPoolMap.end()) return;
+    auto query_pool_state = GetQueryPoolState(queryPool);
+    if (!query_pool_state) return;
 
     // Reset the state of existing entries.
     QueryObject query_obj{queryPool, 0};
-    const uint32_t max_query_count = std::min(queryCount, query_pool_it->second->createInfo.queryCount - firstQuery);
+    const uint32_t max_query_count = std::min(queryCount, query_pool_state->createInfo.queryCount - firstQuery);
     for (uint32_t i = 0; i < max_query_count; ++i) {
         query_obj.query = firstQuery + i;
         auto query_it = queryToStateMap.find(query_obj);
@@ -13511,7 +14454,7 @@ bool CoreChecks::PreCallValidateCmdSetDeviceMask(VkCommandBuffer commandBuffer,
 
 bool CoreChecks::ValidateQueryPoolStride(const std::string &vuid_not_64, const std::string &vuid_64, const VkDeviceSize stride,
                                          const char *parameter_name, const uint64_t parameter_value,
-                                         const VkQueryResultFlags flags) {
+                                         const VkQueryResultFlags flags) const {
     bool skip = false;
     if (flags & VK_QUERY_RESULT_64_BIT) {
         static const int condition_multiples = 0b0111;
@@ -13530,7 +14473,7 @@ bool CoreChecks::ValidateQueryPoolStride(const std::string &vuid_not_64, const s
 }
 
 bool CoreChecks::ValidateCmdDrawStrideWithStruct(VkCommandBuffer commandBuffer, const std::string &vuid, const uint32_t stride,
-                                                 const char *struct_name, const uint32_t struct_size) {
+                                                 const char *struct_name, const uint32_t struct_size) const {
     bool skip = false;
     static const int condition_multiples = 0b0011;
     if ((stride & condition_multiples) || (stride < struct_size)) {
@@ -13543,7 +14486,7 @@ bool CoreChecks::ValidateCmdDrawStrideWithStruct(VkCommandBuffer commandBuffer,
 
 bool CoreChecks::ValidateCmdDrawStrideWithBuffer(VkCommandBuffer commandBuffer, const std::string &vuid, const uint32_t stride,
                                                  const char *struct_name, const uint32_t struct_size, const uint32_t drawCount,
-                                                 const VkDeviceSize offset, const BUFFER_STATE *buffer_state) {
+                                                 const VkDeviceSize offset, const BUFFER_STATE *buffer_state) const {
     bool skip = false;
     uint64_t validation_value = stride * (drawCount - 1) + offset + struct_size;
     if (validation_value > buffer_state->createInfo.size) {
@@ -13577,6 +14520,10 @@ void PIPELINE_STATE::initGraphicsPipeline(ValidationStateTracker *state_data, co
         }
     }
     graphicsPipelineCI.initialize(pCreateInfo, uses_color_attachment, uses_depthstencil_attachment);
+    if (graphicsPipelineCI.pInputAssemblyState) {
+        topology_at_rasterizer = graphicsPipelineCI.pInputAssemblyState->topology;
+    }
+
     stage_state.resize(pCreateInfo->stageCount);
     for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
         const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i];
@@ -13608,9 +14555,6 @@ void PIPELINE_STATE::initGraphicsPipeline(ValidationStateTracker *state_data, co
                 std::vector<VkPipelineColorBlendAttachmentState>(pCBCI->pAttachments, pCBCI->pAttachments + pCBCI->attachmentCount);
         }
     }
-    if (graphicsPipelineCI.pInputAssemblyState) {
-        topology_at_rasterizer = graphicsPipelineCI.pInputAssemblyState->topology;
-    }
     rp_state = rpstate;
 }
 
diff --git a/layers/core_validation.h b/layers/core_validation.h
index 3ece44abc..3f24e1296 100644
--- a/layers/core_validation.h
+++ b/layers/core_validation.h
@@ -125,6 +125,13 @@ struct create_compute_pipeline_api_state {
     const VkComputePipelineCreateInfo* pCreateInfos;
 };
 
+// This structure is used to save data across the CreateRayTracingPipelinesNV down-chain API call.
+struct create_ray_tracing_pipeline_api_state {
+    std::vector<safe_VkRayTracingPipelineCreateInfoNV> gpu_create_infos;
+    std::vector<std::unique_ptr<PIPELINE_STATE>> pipe_state;
+    const VkRayTracingPipelineCreateInfoNV* pCreateInfos;
+};
+
 // This structure is used modify parameters for the CreatePipelineLayout down-chain API call
 struct create_pipeline_layout_api_state {
     std::vector<VkDescriptorSetLayout> new_layouts;
@@ -170,6 +177,11 @@ struct SURFACE_STATE {
     SURFACE_STATE(VkSurfaceKHR surface) : surface(surface) {}
 };
 
+struct SubpassLayout {
+    uint32_t index;
+    VkImageLayout layout;
+};
+
 using std::unordered_map;
 struct GpuValidationState;
 
@@ -197,13 +209,11 @@ class ValidationStateTracker : public ValidationObject {
     //  TODO -- make consistent with traits approach below.
     unordered_map<VkQueue, QUEUE_STATE> queueMap;
     unordered_map<VkEvent, EVENT_STATE> eventMap;
-    unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> imageLayoutMap;
 
     unordered_map<VkRenderPass, std::shared_ptr<RENDER_PASS_STATE>> renderPassMap;
     unordered_map<VkDescriptorSetLayout, std::shared_ptr<cvdescriptorset::DescriptorSetLayout>> descriptorSetLayoutMap;
 
     std::unordered_set<VkQueue> queues;  // All queues under given device
-    unordered_map<VkImage, std::vector<ImageSubresourcePair>> imageSubresourceMap;
     std::map<QueryObject, QueryState> queryToStateMap;
     unordered_map<VkSamplerYcbcrConversion, uint64_t> ycbcr_conversion_ahb_fmt_map;
 
@@ -333,10 +343,13 @@ class ValidationStateTracker : public ValidationObject {
 
     // Class Declarations for helper functions
     IMAGE_VIEW_STATE* GetAttachmentImageViewState(FRAMEBUFFER_STATE* framebuffer, uint32_t index);
+    const RENDER_PASS_STATE* GetRenderPassState(VkRenderPass renderpass) const;
     RENDER_PASS_STATE* GetRenderPassState(VkRenderPass renderpass);
     std::shared_ptr<RENDER_PASS_STATE> GetRenderPassStateSharedPtr(VkRenderPass renderpass);
     EVENT_STATE* GetEventState(VkEvent event);
+    const QUEUE_STATE* GetQueueState(VkQueue queue) const;
     QUEUE_STATE* GetQueueState(VkQueue queue);
+    const BINDABLE* GetObjectMemBinding(const VulkanTypedHandle& typed_handle) const;
     BINDABLE* GetObjectMemBinding(const VulkanTypedHandle& typed_handle);
 
     // Used for instance versions of this object
@@ -345,8 +358,9 @@ class ValidationStateTracker : public ValidationObject {
     PHYSICAL_DEVICE_STATE* physical_device_state;
 
     // Link for derived device objects back to their parent instance object
-    CoreChecks* instance_state;
+    ValidationStateTracker* instance_state;
 
+    const PHYSICAL_DEVICE_STATE* GetPhysicalDeviceState(VkPhysicalDevice phys) const;
     PHYSICAL_DEVICE_STATE* GetPhysicalDeviceState(VkPhysicalDevice phys);
     PHYSICAL_DEVICE_STATE* GetPhysicalDeviceState();
     const PHYSICAL_DEVICE_STATE* GetPhysicalDeviceState() const;
@@ -358,28 +372,124 @@ class ValidationStateTracker : public ValidationObject {
         command_buffer_reset_callback.reset(new CommandBufferResetCallback(std::forward<Fn>(fn)));
     }
 
+    using SetImageViewInitialLayoutCallback = std::function<void(CMD_BUFFER_STATE*, const IMAGE_VIEW_STATE&, VkImageLayout)>;
+    std::unique_ptr<SetImageViewInitialLayoutCallback> set_image_view_initial_layout_callback;
+    template <typename Fn>
+    void SetSetImageViewInitialLayoutCallback(Fn&& fn) {
+        set_image_view_initial_layout_callback.reset(new SetImageViewInitialLayoutCallback(std::forward<Fn>(fn)));
+    }
+
+    void CallSetImageViewInitialLayoutCallback(CMD_BUFFER_STATE* cb_node, const IMAGE_VIEW_STATE& iv_state, VkImageLayout layout) {
+        if (set_image_view_initial_layout_callback) {
+            (*set_image_view_initial_layout_callback)(cb_node, iv_state, layout);
+        }
+    }
+
     // State update functions
-    // Enumerations
+    // Gets/Enumerations
     void PostCallRecordEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
                                                      VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties,
                                                      VkResult result);
     void PostCallRecordEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount,
                                                         VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties,
                                                         VkResult result);
+    void PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
+                                                VkPhysicalDevice* pPhysicalDevices, VkResult result);
+    void PostCallRecordGetAccelerationStructureMemoryRequirementsNV(VkDevice device,
+                                                                    const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
+                                                                    VkMemoryRequirements2KHR* pMemoryRequirements);
+    void PostCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+    void PostCallRecordGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo,
+                                                    VkMemoryRequirements2KHR* pMemoryRequirements);
+    void PostCallRecordGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo,
+                                                       VkMemoryRequirements2KHR* pMemoryRequirements);
+    void PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
+    void PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
+    void PostCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
+    void PostCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+                                                   VkMemoryRequirements2* pMemoryRequirements);
+    void PostCallRecordGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
+                                                      VkMemoryRequirements2* pMemoryRequirements);
+    void PostCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
+                                                        VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+    void PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
+                                                         uint32_t* pSparseMemoryRequirementCount,
+                                                         VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
+    void PostCallRecordGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
+                                                            uint32_t* pSparseMemoryRequirementCount,
+                                                            VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
+    void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+                                                                  VkDisplayPlanePropertiesKHR* pProperties, VkResult result);
+    void PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+                                                                   VkDisplayPlaneProperties2KHR* pProperties, VkResult result);
+    void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+                                                              VkQueueFamilyProperties* pQueueFamilyProperties);
+    void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
+                                                               VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
+    void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
+                                                                  uint32_t* pQueueFamilyPropertyCount,
+                                                                  VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
+    void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                               VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, VkResult result);
+    void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
+                                                                const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                                VkSurfaceCapabilities2KHR* pSurfaceCapabilities, VkResult result);
+    void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                                VkSurfaceCapabilities2EXT* pSurfaceCapabilities, VkResult result);
+    void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                          uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats,
+                                                          VkResult result);
+    void PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
+                                                           const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
+                                                           uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats,
+                                                           VkResult result);
+    void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
+                                                               uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes,
+                                                               VkResult result);
+    void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
+                                                          VkSurfaceKHR surface, VkBool32* pSupported, VkResult result);
+
+    // Create/Destroy/Bind
+    void PostCallRecordBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
+                                                         const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
+                                                         VkResult result);
+    void PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset,
+                                        VkResult result);
+    void PostCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos,
+                                         VkResult result);
+    void PostCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos,
+                                            VkResult result);
+    void PostCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset,
+                                       VkResult result);
+    void PostCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos,
+                                        VkResult result);
+    void PostCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos,
+                                           VkResult result);
 
-    // Create/Destroy
     void PostCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo,
                                     const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, VkResult result);
     void PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
 
+    void PostCallRecordCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+                                                     const VkAllocationCallbacks* pAllocator,
+                                                     VkAccelerationStructureNV* pAccelerationStructure, VkResult result);
+    void PreCallRecordDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
+                                                     const VkAllocationCallbacks* pAllocator);
     void PostCallRecordCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
                                     VkBuffer* pBuffer, VkResult result);
     void PreCallRecordDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
     void PostCallRecordCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
                                         const VkAllocationCallbacks* pAllocator, VkBufferView* pView, VkResult result);
     void PreCallRecordDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
-    void PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
-                                   VkImage* pImage, VkResult result);
+    void PostCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
+                                         const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, VkResult result);
+    void PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
+                                                    const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
+                                                    VkResult result);
+    void PostCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                   VkEvent* pEvent, VkResult result);
+    void PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
     void PostCallRecordCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo,
                                             const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool,
                                             VkResult result);
@@ -390,6 +500,13 @@ class ValidationStateTracker : public ValidationObject {
                                                  VkResult result);
     void PostCallRecordResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags, VkResult result);
     void PostCallRecordResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, VkResult result);
+    bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                               const VkComputePipelineCreateInfo* pCreateInfos,
+                                               const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state);
+    void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                              const VkComputePipelineCreateInfo* pCreateInfos,
+                                              const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result,
+                                              void* pipe_state);
     void PostCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags,
                                            VkResult result);
     void PreCallRecordDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout,
@@ -405,13 +522,12 @@ class ValidationStateTracker : public ValidationObject {
                                                       const VkAllocationCallbacks* pAllocator);
     void PreCallRecordDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
                                                          const VkAllocationCallbacks* pAllocator);
-    bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
-                                               const VkComputePipelineCreateInfo* pCreateInfos,
-                                               const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state);
-    void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
-                                              const VkComputePipelineCreateInfo* pCreateInfos,
-                                              const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result,
-                                              void* pipe_state);
+    void PostCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                   VkFence* pFence, VkResult result);
+    void PreCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
+                                         const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, VkResult result);
+    void PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
                                                 const VkGraphicsPipelineCreateInfo* pCreateInfos,
                                                 const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state);
@@ -419,16 +535,23 @@ class ValidationStateTracker : public ValidationObject {
                                                const VkGraphicsPipelineCreateInfo* pCreateInfos,
                                                const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result,
                                                void* cgpl_state);
+    void PostCallRecordCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+                                   VkImage* pImage, VkResult result);
     void PreCallRecordDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
     void PostCallRecordCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo,
                                        const VkAllocationCallbacks* pAllocator, VkImageView* pView, VkResult result);
     void PreCallRecordDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+
     void PreCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
     void PostCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo,
                                             const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout,
                                             VkResult result);
     void PreCallRecordDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
                                             const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
+                                       const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, VkResult result);
+    void PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
     bool PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
                                                     const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
                                                     const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
@@ -437,16 +560,49 @@ class ValidationStateTracker : public ValidationObject {
                                                    const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
                                                    const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result,
                                                    void* pipe_state);
+    void PostCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
+                                        const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result);
+    void PostCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo,
+                                            const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result);
+    void PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
+                                     const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, VkResult result);
+    void PreCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+                                                    const VkAllocationCallbacks* pAllocator,
+                                                    VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result);
+    void PostCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+                                                     const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
+                                                       const VkAllocationCallbacks* pAllocator,
+                                                       VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result);
+    void PostCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
+                                                        const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
+                                       const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, VkResult result);
+    void PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
     void PostCallRecordCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo,
                                           const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, VkResult result,
                                           void* csm_state);
     void PreCallRecordDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+    void PreCallRecordDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
+    void PostCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
+                                                 const VkSwapchainCreateInfoKHR* pCreateInfos,
+                                                 const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains,
+                                                 VkResult result);
+    void PostCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
+                                          const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain, VkResult result);
+    void PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
 
     // CommandBuffer Control
     void PreCallRecordBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
     void PostCallRecordEndCommandBuffer(VkCommandBuffer commandBuffer, VkResult result);
+    void PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence,
+                                   VkResult result);
 
     // Allocate/Free
+    void PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pCreateInfo,
+                                              VkCommandBuffer* pCommandBuffer, VkResult result);
     void PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo,
                                               VkDescriptorSet* pDescriptorSets, VkResult result, void* ads_state);
     void PostCallRecordAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo,
@@ -465,20 +621,39 @@ class ValidationStateTracker : public ValidationObject {
                                                          VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
 
     // Recorded Commands
+    void PreCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
+    void PostCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags);
+    void PostCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                               VkQueryControlFlags flags, uint32_t index);
+    void PreCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                         VkSubpassContents contents);
+    void PreCallRecordCmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                             const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
     void PreCallRecordCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
                                             VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount,
                                             const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount,
                                             const uint32_t* pDynamicOffsets);
+    void PreCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                         VkIndexType indexType);
     void PreCallRecordCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+    void PreCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
+    void PreCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
+                                           const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
     void PreCallRecordCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage,
                                    VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions,
                                    VkFilter filter);
+    void PostCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo,
+                                                       VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update,
+                                                       VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
+                                                       VkBuffer scratch, VkDeviceSize scratchOffset);
     void PreCallRecordCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
                                          const VkClearColorValue* pColor, uint32_t rangeCount,
                                          const VkImageSubresourceRange* pRanges);
     void PreCallRecordCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
                                                 const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount,
                                                 const VkImageSubresourceRange* pRanges);
+    void PostCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
+                                                      VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode);
     void PreCallRecordCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount,
                                     const VkBufferCopy* pRegions);
     void PreCallRecordCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage,
@@ -487,8 +662,46 @@ class ValidationStateTracker : public ValidationObject {
                                    VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
     void PreCallRecordCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
                                            VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+    void PostCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                               uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride,
+                                               VkQueryResultFlags flags);
+    void PostCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
+    void PostCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+    void PostCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
+                               uint32_t firstInstance);
+    void PostCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
+                                      uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+    void PostCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
+                                              uint32_t stride);
+    void PostCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
+                                       uint32_t stride);
+    void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                     VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                     uint32_t stride);
+    void PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                              VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                              uint32_t stride);
+    void PreCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                      VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                      uint32_t stride);
+    void PreCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                 uint32_t drawCount, uint32_t stride);
+    void PreCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
+    void PostCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer);
+    void PostCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot);
+    void PostCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
+    void PostCallRecordCmdEndRenderPass(VkCommandBuffer commandBuffer);
+    void PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo);
+    void PreCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
+                                         const VkCommandBuffer* pCommandBuffers);
     void PreCallRecordCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size,
                                     uint32_t data);
+    void PreCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
+    void PostCallRecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+    void PostCallRecordCmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
+                                          const VkSubpassEndInfoKHR* pSubpassEndInfo);
+    void PostCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                         uint32_t queryCount);
     void PreCallRecordCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
                                       VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
                                       const VkImageResolve* pRegions);
@@ -499,6 +712,7 @@ class ValidationStateTracker : public ValidationObject {
     void PreCallRecordCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
                                                uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
     void PreCallRecordCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
+    void PreCallRecordCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);
     void PreCallRecordCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount,
                                     const VkRect2D* pScissors);
     void PreCallRecordCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
@@ -512,44 +726,129 @@ class ValidationStateTracker : public ValidationObject {
     void PostCallRecordCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                        VkDeviceSize dataSize, const void* pData);
 
+    // WSI
+    void PostCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore,
+                                           VkFence fence, uint32_t* pImageIndex, VkResult result);
+    void PostCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex,
+                                            VkResult result);
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+    void PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
+                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
+#endif  // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_IOS_MVK
+    void PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
+                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
+#endif  // VK_USE_PLATFORM_IOS_MVK
+#ifdef VK_USE_PLATFORM_MACOS_MVK
+    void PostCallRecordCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
+                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
+#endif  // VK_USE_PLATFORM_MACOS_MVK
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+    void PostCallRecordCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
+                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
+#endif  // VK_USE_PLATFORM_WIN32_KHR
+#ifdef VK_USE_PLATFORM_WAYLAND_KHR
+    void PostCallRecordCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
+                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
+#endif  // VK_USE_PLATFORM_WAYLAND_KHR
+#ifdef VK_USE_PLATFORM_XCB_KHR
+    void PostCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
+                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
+#endif  // VK_USE_PLATFORM_XCB_KHR
+#ifdef VK_USE_PLATFORM_XLIB_KHR
+    void PostCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
+#endif  // VK_USE_PLATFORM_XLIB_KHR
+
     // State Utilty functions
+    void AddCommandBufferBinding(std::unordered_set<CMD_BUFFER_STATE*>* cb_bindings, const VulkanTypedHandle& obj,
+                                 CMD_BUFFER_STATE* cb_node);
+    void AddCommandBufferBindingAccelerationStructure(CMD_BUFFER_STATE*, ACCELERATION_STRUCTURE_STATE*);
     void AddCommandBufferBindingBuffer(CMD_BUFFER_STATE*, BUFFER_STATE*);
     void AddCommandBufferBindingBufferView(CMD_BUFFER_STATE*, BUFFER_VIEW_STATE*);
     void AddCommandBufferBindingImage(CMD_BUFFER_STATE*, IMAGE_STATE*);
     void AddCommandBufferBindingImageView(CMD_BUFFER_STATE*, IMAGE_VIEW_STATE*);
+    void AddCommandBufferBindingSampler(CMD_BUFFER_STATE*, SAMPLER_STATE*);
     void AddMemObjInfo(void* object, const VkDeviceMemory mem, const VkMemoryAllocateInfo* pAllocateInfo);
     void AddFramebufferBinding(CMD_BUFFER_STATE* cb_state, FRAMEBUFFER_STATE* fb_state);
     void ClearCmdBufAndMemReferences(CMD_BUFFER_STATE* cb_node);
     void ClearMemoryObjectBindings(const VulkanTypedHandle& typed_handle);
     void ClearMemoryObjectBinding(const VulkanTypedHandle& typed_handle, VkDeviceMemory mem);
+    void DecrementBoundResources(CMD_BUFFER_STATE const* cb_node);
     void DeleteDescriptorSetPools();
     void FreeCommandBufferStates(COMMAND_POOL_STATE* pool_state, const uint32_t command_buffer_count,
                                  const VkCommandBuffer* command_buffers);
     void FreeDescriptorSet(cvdescriptorset::DescriptorSet* descriptor_set);
     BASE_NODE* GetStateStructPtrFromObject(const VulkanTypedHandle& object_struct);
+    void IncrementBoundObjects(CMD_BUFFER_STATE const* cb_node);
+    void IncrementResources(CMD_BUFFER_STATE* cb_node);
+    void InsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, DEVICE_MEMORY_STATE* mem_info,
+                                                VkDeviceSize mem_offset, const VkMemoryRequirements& mem_reqs);
+    void InsertBufferMemoryRange(VkBuffer buffer, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
+                                 const VkMemoryRequirements& mem_reqs);
+    void InsertImageMemoryRange(VkImage image, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
+                                VkMemoryRequirements mem_reqs, bool is_linear);
+    void InsertMemoryRange(const VulkanTypedHandle& typed_handle, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize memoryOffset,
+                           VkMemoryRequirements memRequirements, bool is_linear);
     void InvalidateCommandBuffers(std::unordered_set<CMD_BUFFER_STATE*> const& cb_nodes, const VulkanTypedHandle& obj);
     void PerformAllocateDescriptorSets(const VkDescriptorSetAllocateInfo*, const VkDescriptorSet*,
                                        const cvdescriptorset::AllocateDescriptorSetsData*);
     void PerformUpdateDescriptorSetsWithTemplateKHR(VkDescriptorSet descriptorSet, const TEMPLATE_STATE* template_state,
                                                     const void* pData);
+    void RecordAcquireNextImageState(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore,
+                                     VkFence fence, uint32_t* pImageIndex);
+    void RecordCmdBeginQuery(CMD_BUFFER_STATE* cb_state, const QueryObject& query_obj);
+    void RecordCmdEndQuery(CMD_BUFFER_STATE* cb_state, const QueryObject& query_obj);
+    void RecordCmdEndRenderPassState(VkCommandBuffer commandBuffer);
+    void RecordCmdBeginRenderPassState(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                       const VkSubpassContents contents);
+    void RecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
     void RecordCreateImageANDROID(const VkImageCreateInfo* create_info, IMAGE_STATE* is_node);
+    void RecordCreateRenderPassState(RenderPassCreateVersion rp_version, std::shared_ptr<RENDER_PASS_STATE>& render_pass,
+                                     VkRenderPass* pRenderPass);
+    void RecordCreateSamplerYcbcrConversionState(const VkSamplerYcbcrConversionCreateInfo* create_info,
+                                                 VkSamplerYcbcrConversion ycbcr_conversion);
+    void RecordCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo* create_info,
+                                                   VkSamplerYcbcrConversion ycbcr_conversion);
+    void RecordCreateSwapchainState(VkResult result, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain,
+                                    SURFACE_STATE* surface_state, SWAPCHAIN_NODE* old_swapchain_state);
+    void RecordDestroySamplerYcbcrConversionANDROID(VkSamplerYcbcrConversion ycbcr_conversion);
     void RecordEnumeratePhysicalDeviceGroupsState(uint32_t* pPhysicalDeviceGroupCount,
                                                   VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties);
+    void RecordGetBufferMemoryRequirementsState(VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
+    void RecordGetDeviceQueueState(uint32_t queue_family_index, VkQueue queue);
+    void RecordGetImageMemoryRequiementsState(VkImage image, VkMemoryRequirements* pMemoryRequirements);
+    void RecordGetPhysicalDeviceDisplayPlanePropertiesState(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
+                                                            void* pProperties);
     void RecordUpdateDescriptorSetWithTemplateState(VkDescriptorSet descriptorSet,
                                                     VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData);
     void RecordCreateDescriptorUpdateTemplateState(const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
                                                    VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
     void RecordPipelineShaderStage(const VkPipelineShaderStageCreateInfo* pStage, PIPELINE_STATE* pipeline,
                                    PIPELINE_STATE::StageState* stage_state);
+    void RecordRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR* pCreateInfo,
+                             RENDER_PASS_STATE* render_pass);
+    void RecordVulkanSurface(VkSurfaceKHR* pSurface);
     void RemoveAccelerationStructureMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE* mem_info);
     void RemoveCommandBufferBinding(const VulkanTypedHandle& object, CMD_BUFFER_STATE* cb_node);
     void RemoveBufferMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE* mem_info);
     void RemoveImageMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE* mem_info);
     void ResetCommandBufferState(const VkCommandBuffer cb);
+    void RetireWorkOnQueue(QUEUE_STATE* pQueue, uint64_t seq, bool switch_finished_queries);
+    void SetMemBinding(VkDeviceMemory mem, BINDABLE* mem_binding, VkDeviceSize memory_offset,
+                       const VulkanTypedHandle& typed_handle);
+    bool SetQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject object, QueryState value);
+    bool SetQueryStateMulti(VkQueue queue, VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                            uint32_t queryCount, QueryState value);
+    void UpdateBindBufferMemoryState(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset);
+    void UpdateBindImageMemoryState(const VkBindImageMemoryInfo& bindInfo);
     void UpdateLastBoundDescriptorSets(CMD_BUFFER_STATE* cb_state, VkPipelineBindPoint pipeline_bind_point,
                                        const PIPELINE_LAYOUT_STATE* pipeline_layout, uint32_t first_set, uint32_t set_count,
-                                       const std::vector<cvdescriptorset::DescriptorSet*> descriptor_sets,
+                                       const VkDescriptorSet* pDescriptorSets, cvdescriptorset::DescriptorSet* push_descriptor_set,
                                        uint32_t dynamic_offset_count, const uint32_t* p_dynamic_offsets);
+    void UpdateStateCmdDrawDispatchType(CMD_BUFFER_STATE* cb_state, VkPipelineBindPoint bind_point);
+    void UpdateStateCmdDrawType(CMD_BUFFER_STATE* cb_state, VkPipelineBindPoint bind_point);
+    void UpdateDrawState(CMD_BUFFER_STATE* cb_state, const VkPipelineBindPoint bind_point);
 
     DeviceFeatures enabled_features = {};
     // Device specific data
@@ -570,6 +869,8 @@ class ValidationStateTracker : public ValidationObject {
         VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback_props;
         VkPhysicalDeviceSubgroupProperties subgroup_props;
         VkPhysicalDeviceRayTracingPropertiesNV ray_tracing_props;
+        VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT texel_buffer_alignment_props;
+        VkPhysicalDeviceFragmentDensityMapPropertiesEXT fragment_density_map_props;
     };
     DeviceExtensionProperties phys_dev_ext_props = {};
     std::vector<VkCooperativeMatrixPropertiesNV> cooperative_matrix_properties;
@@ -586,6 +887,9 @@ class ValidationStateTracker : public ValidationObject {
             DispatchGetPhysicalDeviceProperties2KHR(gpu, &prop2);
         }
     }
+
+    // This controls output of a state tracking warning (s.t. it only emits once)
+    bool external_sync_warning = false;
 };
 
 class CoreChecks : public ValidationStateTracker {
@@ -595,26 +899,21 @@ class CoreChecks : public ValidationStateTracker {
     GlobalQFOTransferBarrierMap<VkImageMemoryBarrier> qfo_release_image_barrier_map;
     GlobalQFOTransferBarrierMap<VkBufferMemoryBarrier> qfo_release_buffer_barrier_map;
     unordered_map<VkImage, std::vector<ImageSubresourcePair>> imageSubresourceMap;
+    using ImageSubresPairLayoutMap = std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE>;
+    ImageSubresPairLayoutMap imageLayoutMap;
 
-    bool external_sync_warning = false;
     std::unique_ptr<GpuValidationState> gpu_validation_state;
 
     bool VerifyQueueStateToSeq(QUEUE_STATE* initial_queue, uint64_t initial_seq);
-    void SetMemBinding(VkDeviceMemory mem, BINDABLE* mem_binding, VkDeviceSize memory_offset,
-                       const VulkanTypedHandle& typed_handle);
-    bool ValidateSetMemBinding(VkDeviceMemory mem, const VulkanTypedHandle& typed_handle, const char* apiName);
+    bool ValidateSetMemBinding(VkDeviceMemory mem, const VulkanTypedHandle& typed_handle, const char* apiName) const;
     bool SetSparseMemBinding(MEM_BINDING binding, const VulkanTypedHandle& typed_handle);
     bool ValidateDeviceQueueFamily(uint32_t queue_family, const char* cmd_name, const char* parameter_name, const char* error_code,
-                                   bool optional);
-    bool ValidateBindBufferMemory(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset, const char* api_name);
-    void RecordGetBufferMemoryRequirementsState(VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-    void UpdateBindBufferMemoryState(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset);
-    bool ValidateGetImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2* pInfo);
-    void RecordGetImageMemoryRequiementsState(VkImage image, VkMemoryRequirements* pMemoryRequirements);
+                                   bool optional) const;
+    bool ValidateBindBufferMemory(VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset, const char* api_name) const;
+    bool ValidateGetImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2* pInfo) const;
     bool CheckCommandBuffersInFlight(const COMMAND_POOL_STATE* pPool, const char* action, const char* error_code) const;
     bool CheckCommandBufferInFlight(const CMD_BUFFER_STATE* cb_node, const char* action, const char* error_code) const;
     bool VerifyQueueStateToFence(VkFence fence);
-    void DecrementBoundResources(CMD_BUFFER_STATE const* cb_node);
     bool VerifyWaitFenceState(VkFence fence, const char* apiCall);
     void RetireFence(VkFence fence);
     void StoreMemRanges(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size);
@@ -622,21 +921,27 @@ class CoreChecks : public ValidationStateTracker {
     void InitializeAndTrackMemory(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, void** ppData);
     bool ValidatePipelineLocked(std::vector<std::unique_ptr<PIPELINE_STATE>> const& pPipelines, int pipelineIndex) const;
     bool ValidatePipelineUnlocked(const PIPELINE_STATE* pPipeline, uint32_t pipelineIndex) const;
-    bool ValidImageBufferQueue(CMD_BUFFER_STATE* cb_node, const VulkanTypedHandle& object, VkQueue queue, uint32_t count,
-                               const uint32_t* indices);
-    bool ValidateFenceForSubmit(FENCE_STATE* pFence);
-    bool ValidateStatus(CMD_BUFFER_STATE* pNode, CBStatusFlags status_mask, VkFlags msg_flags, const char* fail_msg,
-                        const char* msg_code);
-    bool ValidateDrawStateFlags(CMD_BUFFER_STATE* pCB, const PIPELINE_STATE* pPipe, bool indexed, const char* msg_code);
+    bool ValidImageBufferQueue(const CMD_BUFFER_STATE* cb_node, const VulkanTypedHandle& object, VkQueue queue, uint32_t count,
+                               const uint32_t* indices) const;
+    bool ValidateFenceForSubmit(const FENCE_STATE* pFence) const;
+    bool ValidateSemaphoresForSubmit(VkQueue queue, const VkSubmitInfo* submit,
+                                     std::unordered_set<VkSemaphore>* unsignaled_sema_arg,
+                                     std::unordered_set<VkSemaphore>* signaled_sema_arg,
+                                     std::unordered_set<VkSemaphore>* internal_sema_arg) const;
+    bool ValidateCommandBuffersForSubmit(VkQueue queue, const VkSubmitInfo* submit,
+                                         ImageSubresPairLayoutMap* localImageLayoutMap_arg,
+                                         std::vector<VkCommandBuffer>* current_cmds_arg) const;
+    bool ValidateStatus(const CMD_BUFFER_STATE* pNode, CBStatusFlags status_mask, VkFlags msg_flags, const char* fail_msg,
+                        const char* msg_code) const;
+    bool ValidateDrawStateFlags(const CMD_BUFFER_STATE* pCB, const PIPELINE_STATE* pPipe, bool indexed, const char* msg_code) const;
     bool LogInvalidAttachmentMessage(const char* type1_string, const RENDER_PASS_STATE* rp1_state, const char* type2_string,
                                      const RENDER_PASS_STATE* rp2_state, uint32_t primary_attach, uint32_t secondary_attach,
                                      const char* msg, const char* caller, const char* error_code) const;
     bool ValidateStageMaskGsTsEnables(VkPipelineStageFlags stageMask, const char* caller, const char* geo_error_id,
-                                      const char* tess_error_id, const char* mesh_error_id, const char* task_error_id);
+                                      const char* tess_error_id, const char* mesh_error_id, const char* task_error_id) const;
     bool ValidateMapMemRange(VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size);
     bool ValidatePushConstantRange(const uint32_t offset, const uint32_t size, const char* caller_name, uint32_t index) const;
-    bool ValidateRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR* pCreateInfo,
-                               RENDER_PASS_STATE* render_pass);
+    bool ValidateRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR* pCreateInfo) const;
     bool ValidateAttachmentCompatibility(const char* type1_string, const RENDER_PASS_STATE* rp1_state, const char* type2_string,
                                          const RENDER_PASS_STATE* rp2_state, uint32_t primary_attach, uint32_t secondary_attach,
                                          const char* caller, const char* error_code) const;
@@ -645,7 +950,6 @@ class CoreChecks : public ValidationStateTracker {
                                       const char* error_code) const;
     bool ValidateRenderPassCompatibility(const char* type1_string, const RENDER_PASS_STATE* rp1_state, const char* type2_string,
                                          const RENDER_PASS_STATE* rp2_state, const char* caller, const char* error_code) const;
-    void UpdateDrawState(CMD_BUFFER_STATE* cb_state, const VkPipelineBindPoint bind_point);
     bool ReportInvalidCommandBuffer(const CMD_BUFFER_STATE* cb_state, const char* call_source) const;
     void InitGpuValidation();
     bool ValidateQueueFamilyIndex(const PHYSICAL_DEVICE_STATE* pd_state, uint32_t requested_queue_family, const char* err_code,
@@ -658,21 +962,19 @@ class CoreChecks : public ValidationStateTracker {
     bool ValidateImageBarrierImage(const char* funcName, CMD_BUFFER_STATE const* cb_state, VkFramebuffer framebuffer,
                                    uint32_t active_subpass, const safe_VkSubpassDescription2KHR& sub_desc,
                                    const VulkanTypedHandle& rp_handle, uint32_t img_index, const VkImageMemoryBarrier& img_barrier);
-    void RecordCmdBeginRenderPassState(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
-                                       const VkSubpassContents contents);
     bool ValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, RenderPassCreateVersion rp_version,
-                                    const VkRenderPassBeginInfo* pRenderPassBegin);
-    bool ValidateDependencies(FRAMEBUFFER_STATE const* framebuffer, RENDER_PASS_STATE const* renderPass);
+                                    const VkRenderPassBeginInfo* pRenderPassBegin) const;
+    bool ValidateDependencies(FRAMEBUFFER_STATE const* framebuffer, RENDER_PASS_STATE const* renderPass) const;
     bool ValidateBarriers(const char* funcName, CMD_BUFFER_STATE* cb_state, VkPipelineStageFlags src_stage_mask,
                           VkPipelineStageFlags dst_stage_mask, uint32_t memBarrierCount, const VkMemoryBarrier* pMemBarriers,
                           uint32_t bufferBarrierCount, const VkBufferMemoryBarrier* pBufferMemBarriers,
                           uint32_t imageMemBarrierCount, const VkImageMemoryBarrier* pImageMemBarriers);
-    bool ValidateBarrierQueueFamilies(const char* func_name, CMD_BUFFER_STATE* cb_state, const VkImageMemoryBarrier* barrier,
+    bool ValidateBarrierQueueFamilies(const char* func_name, CMD_BUFFER_STATE* cb_state, const VkImageMemoryBarrier& barrier,
                                       const IMAGE_STATE* state_data);
-    bool ValidateBarrierQueueFamilies(const char* func_name, CMD_BUFFER_STATE* cb_state, const VkBufferMemoryBarrier* barrier,
+    bool ValidateBarrierQueueFamilies(const char* func_name, CMD_BUFFER_STATE* cb_state, const VkBufferMemoryBarrier& barrier,
                                       const BUFFER_STATE* state_data);
-    bool ValidateCreateSwapchain(const char* func_name, VkSwapchainCreateInfoKHR const* pCreateInfo, SURFACE_STATE* surface_state,
-                                 SWAPCHAIN_NODE* old_swapchain_state);
+    bool ValidateCreateSwapchain(const char* func_name, VkSwapchainCreateInfoKHR const* pCreateInfo,
+                                 const SURFACE_STATE* surface_state, const SWAPCHAIN_NODE* old_swapchain_state) const;
     void RecordCmdPushDescriptorSetState(CMD_BUFFER_STATE* cb_state, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout,
                                          uint32_t set, uint32_t descriptorWriteCount,
                                          const VkWriteDescriptorSet* pDescriptorWrites);
@@ -695,102 +997,78 @@ class CoreChecks : public ValidationStateTracker {
                                          const safe_VkSubpassDependency2KHR* dependencies,
                                          const std::vector<uint32_t>& self_dependencies, uint32_t image_mem_barrier_count,
                                          const VkImageMemoryBarrier* image_barriers);
-    bool ValidateSecondaryCommandBufferState(CMD_BUFFER_STATE* pCB, CMD_BUFFER_STATE* pSubCB);
+    bool ValidateSecondaryCommandBufferState(const CMD_BUFFER_STATE* pCB, const CMD_BUFFER_STATE* pSubCB);
     bool ValidateFramebuffer(VkCommandBuffer primaryBuffer, const CMD_BUFFER_STATE* pCB, VkCommandBuffer secondaryBuffer,
                              const CMD_BUFFER_STATE* pSubCB, const char* caller);
     bool ValidateDescriptorUpdateTemplate(const char* func_name, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo);
-    bool ValidateCreateSamplerYcbcrConversion(const char* func_name, const VkSamplerYcbcrConversionCreateInfo* create_info);
-    void RecordCreateSamplerYcbcrConversionState(const VkSamplerYcbcrConversionCreateInfo* create_info,
-                                                 VkSamplerYcbcrConversion ycbcr_conversion);
+    bool ValidateCreateSamplerYcbcrConversion(const char* func_name, const VkSamplerYcbcrConversionCreateInfo* create_info) const;
     bool ValidateImportFence(VkFence fence, const char* caller_name);
     void RecordImportFenceState(VkFence fence, VkExternalFenceHandleTypeFlagBitsKHR handle_type, VkFenceImportFlagsKHR flags);
     void RecordGetExternalFenceState(VkFence fence, VkExternalFenceHandleTypeFlagBitsKHR handle_type);
     bool ValidateAcquireNextImage(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence,
-                                  uint32_t* pImageIndex, const char* func_name);
-    void RecordAcquireNextImageState(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore,
-                                     VkFence fence, uint32_t* pImageIndex);
-    bool VerifyRenderAreaBounds(const VkRenderPassBeginInfo* pRenderPassBegin);
-    bool ValidatePrimaryCommandBuffer(const CMD_BUFFER_STATE* pCB, char const* cmd_name, const char* error_code);
-    void RecordCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
-    bool ValidateCmdEndRenderPass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer);
-    void RecordCmdEndRenderPassState(VkCommandBuffer commandBuffer);
-    bool ValidateFramebufferCreateInfo(const VkFramebufferCreateInfo* pCreateInfo);
+                                  uint32_t* pImageIndex, const char* func_name) const;
+    bool VerifyRenderAreaBounds(const VkRenderPassBeginInfo* pRenderPassBegin) const;
+    bool VerifyFramebufferAndRenderPassImageViews(const VkRenderPassBeginInfo* pRenderPassBeginInfo) const;
+    bool ValidatePrimaryCommandBuffer(const CMD_BUFFER_STATE* pCB, char const* cmd_name, const char* error_code) const;
+    void RecordCmdNextSubpassLayouts(VkCommandBuffer commandBuffer, VkSubpassContents contents);
+    bool ValidateCmdEndRenderPass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer) const;
+    void RecordCmdEndRenderPassLayouts(VkCommandBuffer commandBuffer);
+    bool ValidateFramebufferCreateInfo(const VkFramebufferCreateInfo* pCreateInfo) const;
     bool MatchUsage(uint32_t count, const VkAttachmentReference2KHR* attachments, const VkFramebufferCreateInfo* fbci,
-                    VkImageUsageFlagBits usage_flag, const char* error_code);
-    bool CheckDependencyExists(const uint32_t subpass, const std::vector<uint32_t>& dependent_subpasses,
-                               const std::vector<DAGNode>& subpass_to_node, bool& skip);
+                    VkImageUsageFlagBits usage_flag, const char* error_code) const;
+    bool IsImageLayoutReadOnly(VkImageLayout layout) const;
+    bool CheckDependencyExists(const uint32_t subpass, const VkImageLayout layout,
+                               const std::vector<SubpassLayout>& dependent_subpasses, const std::vector<DAGNode>& subpass_to_node,
+                               bool& skip) const;
     bool CheckPreserved(const VkRenderPassCreateInfo2KHR* pCreateInfo, const int index, const uint32_t attachment,
-                        const std::vector<DAGNode>& subpass_to_node, int depth, bool& skip);
-    bool ValidateBindImageMemory(const VkBindImageMemoryInfo& bindInfo, const char* api_name);
-    void UpdateBindImageMemoryState(const VkBindImageMemoryInfo& bindInfo);
-    void RecordGetPhysicalDeviceDisplayPlanePropertiesState(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
-                                                            void* pProperties);
+                        const std::vector<DAGNode>& subpass_to_node, int depth, bool& skip) const;
+    bool ValidateBindImageMemory(const VkBindImageMemoryInfo& bindInfo, const char* api_name) const;
     bool ValidateGetPhysicalDeviceDisplayPlanePropertiesKHRQuery(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
-                                                                 const char* api_name);
+                                                                 const char* api_name) const;
     bool ValidateQuery(VkQueue queue, CMD_BUFFER_STATE* pCB, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount,
-                       VkQueryResultFlags flags);
-    QueryState GetQueryState(QUEUE_STATE* queue_data, VkQueryPool queryPool, uint32_t queryIndex);
-    QueryResultType GetQueryResultType(QueryState state, VkQueryResultFlags flags);
-    bool VerifyQueryIsReset(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject query_obj);
+                       VkQueryResultFlags flags) const;
+    QueryState GetQueryState(const QUEUE_STATE* queue_data, VkQueryPool queryPool, uint32_t queryIndex) const;
+    bool VerifyQueryIsReset(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject query_obj) const;
     bool ValidateImportSemaphore(VkSemaphore semaphore, const char* caller_name);
     void RecordImportSemaphoreState(VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHR handle_type,
                                     VkSemaphoreImportFlagsKHR flags);
     void RecordGetExternalSemaphoreState(VkSemaphore semaphore, VkExternalSemaphoreHandleTypeFlagBitsKHR handle_type);
     bool ValidateBeginQuery(const CMD_BUFFER_STATE* cb_state, const QueryObject& query_obj, VkFlags flags, CMD_TYPE cmd,
                             const char* cmd_name, const char* vuid_queue_flags, const char* vuid_queue_feedback,
-                            const char* vuid_queue_occlusion, const char* vuid_precise, const char* vuid_query_count);
-    void RecordBeginQuery(CMD_BUFFER_STATE* cb_state, const QueryObject& query_obj);
+                            const char* vuid_queue_occlusion, const char* vuid_precise, const char* vuid_query_count) const;
     bool ValidateCmdEndQuery(const CMD_BUFFER_STATE* cb_state, const QueryObject& query_obj, CMD_TYPE cmd, const char* cmd_name,
-                             const char* vuid_queue_flags, const char* vuid_active_queries);
-    void RecordCmdEndQuery(CMD_BUFFER_STATE* cb_state, const QueryObject& query_obj);
-
-    bool SetQueryState(VkQueue queue, VkCommandBuffer commandBuffer, QueryObject object, QueryState value);
+                             const char* vuid_queue_flags, const char* vuid_active_queries) const;
     bool ValidateCmdDrawType(VkCommandBuffer cmd_buffer, bool indexed, VkPipelineBindPoint bind_point, CMD_TYPE cmd_type,
                              const char* caller, VkQueueFlags queue_flags, const char* queue_flag_code,
-                             const char* renderpass_msg_code, const char* pipebound_msg_code, const char* dynamic_state_msg_code);
-    void UpdateStateCmdDrawDispatchType(CMD_BUFFER_STATE* cb_state, VkPipelineBindPoint bind_point);
-    void UpdateStateCmdDrawType(CMD_BUFFER_STATE* cb_state, VkPipelineBindPoint bind_point);
-    bool ValidateCmdNextSubpass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer);
-    bool RangesIntersect(MEMORY_RANGE const* range1, VkDeviceSize offset, VkDeviceSize end);
-    bool RangesIntersect(MEMORY_RANGE const* range1, MEMORY_RANGE const* range2, bool* skip, bool skip_checks);
-    void RecordCreateSwapchainState(VkResult result, const VkSwapchainCreateInfoKHR* pCreateInfo, VkSwapchainKHR* pSwapchain,
-                                    SURFACE_STATE* surface_state, SWAPCHAIN_NODE* old_swapchain_state);
-    void RecordVulkanSurface(VkSurfaceKHR* pSurface);
-    bool ValidateInsertMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize memoryOffset,
-                                   VkMemoryRequirements memRequirements, VulkanObjectType object_type, bool is_linear,
-                                   const char* api_name);
-    void InsertMemoryRange(uint64_t handle, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize memoryOffset,
-                           VkMemoryRequirements memRequirements, VulkanObjectType object_type, bool is_linear);
-    bool ValidateInsertImageMemoryRange(VkImage image, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
-                                        VkMemoryRequirements mem_reqs, bool is_linear, const char* api_name);
-    void InsertImageMemoryRange(VkImage image, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
-                                VkMemoryRequirements mem_reqs, bool is_linear);
-    bool ValidateInsertBufferMemoryRange(VkBuffer buffer, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
-                                         VkMemoryRequirements mem_reqs, const char* api_name);
-    void InsertBufferMemoryRange(VkBuffer buffer, DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
-                                 VkMemoryRequirements mem_reqs);
-    bool ValidateInsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, DEVICE_MEMORY_STATE* mem_info,
-                                                        VkDeviceSize mem_offset, VkMemoryRequirements mem_reqs,
-                                                        const char* api_name);
-    void InsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, DEVICE_MEMORY_STATE* mem_info,
-                                                VkDeviceSize mem_offset, VkMemoryRequirements mem_reqs);
+                             const char* renderpass_msg_code, const char* pipebound_msg_code,
+                             const char* dynamic_state_msg_code) const;
+    bool ValidateCmdNextSubpass(RenderPassCreateVersion rp_version, VkCommandBuffer commandBuffer) const;
+    bool ValidateInsertMemoryRange(const VulkanTypedHandle& typed_handle, const DEVICE_MEMORY_STATE* mem_info,
+                                   VkDeviceSize memoryOffset, const VkMemoryRequirements& memRequirements, bool is_linear,
+                                   const char* api_name) const;
+    bool ValidateInsertImageMemoryRange(VkImage image, const DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
+                                        const VkMemoryRequirements& mem_reqs, bool is_linear, const char* api_name) const;
+    bool ValidateInsertBufferMemoryRange(VkBuffer buffer, const DEVICE_MEMORY_STATE* mem_info, VkDeviceSize mem_offset,
+                                         const VkMemoryRequirements& mem_reqs, const char* api_name) const;
+    bool ValidateInsertAccelerationStructureMemoryRange(VkAccelerationStructureNV as, const DEVICE_MEMORY_STATE* mem_info,
+                                                        VkDeviceSize mem_offset, const VkMemoryRequirements& mem_reqs,
+                                                        const char* api_name) const;
 
     bool ValidateMemoryTypes(const DEVICE_MEMORY_STATE* mem_info, const uint32_t memory_type_bits, const char* funcName,
-                             const char* msgCode);
-    bool ValidateCommandBufferState(CMD_BUFFER_STATE* cb_state, const char* call_source, int current_submit_count,
-                                    const char* vu_id);
-    bool ValidateCommandBufferSimultaneousUse(CMD_BUFFER_STATE* pCB, int current_submit_count);
+                             const char* msgCode) const;
+    bool ValidateCommandBufferState(const CMD_BUFFER_STATE* cb_state, const char* call_source, int current_submit_count,
+                                    const char* vu_id) const;
+    bool ValidateCommandBufferSimultaneousUse(const CMD_BUFFER_STATE* pCB, int current_submit_count) const;
     bool ValidateGetDeviceQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue, const char* valid_qfi_vuid,
-                                const char* qfi_in_range_vuid);
-    void RecordGetDeviceQueueState(uint32_t queue_family_index, VkQueue queue);
-    bool ValidateRenderpassAttachmentUsage(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR* pCreateInfo);
+                                const char* qfi_in_range_vuid) const;
+    bool ValidateRenderpassAttachmentUsage(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR* pCreateInfo) const;
     bool AddAttachmentUse(RenderPassCreateVersion rp_version, uint32_t subpass, std::vector<uint8_t>& attachment_uses,
                           std::vector<VkImageLayout>& attachment_layouts, uint32_t attachment, uint8_t new_use,
-                          VkImageLayout new_layout);
+                          VkImageLayout new_layout) const;
     bool ValidateAttachmentIndex(RenderPassCreateVersion rp_version, uint32_t attachment, uint32_t attachment_count,
-                                 const char* type);
+                                 const char* type) const;
     bool ValidateCreateRenderPass(VkDevice device, RenderPassCreateVersion rp_version,
-                                  const VkRenderPassCreateInfo2KHR* pCreateInfo, RENDER_PASS_STATE* render_pass);
+                                  const VkRenderPassCreateInfo2KHR* pCreateInfo) const;
     bool ValidateRenderPassPipelineBarriers(const char* funcName, CMD_BUFFER_STATE* cb_state, VkPipelineStageFlags src_stage_mask,
                                             VkPipelineStageFlags dst_stage_mask, VkDependencyFlags dependency_flags,
                                             uint32_t mem_barrier_count, const VkMemoryBarrier* mem_barriers,
@@ -803,8 +1081,6 @@ class CoreChecks : public ValidationStateTracker {
     bool ValidateMemoryIsBoundToBuffer(const BUFFER_STATE*, const char*, const char*) const;
     bool ValidateMemoryIsBoundToImage(const IMAGE_STATE*, const char*, const char*) const;
     bool ValidateMemoryIsBoundToAccelerationStructure(const ACCELERATION_STRUCTURE_STATE*, const char*, const char*) const;
-    void AddCommandBufferBindingSampler(CMD_BUFFER_STATE*, SAMPLER_STATE*);
-    void AddCommandBufferBindingAccelerationStructure(CMD_BUFFER_STATE*, ACCELERATION_STRUCTURE_STATE*);
     bool ValidateObjectNotInUse(const BASE_NODE* obj_node, const VulkanTypedHandle& obj_struct, const char* caller_name,
                                 const char* error_code) const;
     bool ValidateCmdQueueFlags(const CMD_BUFFER_STATE* cb_node, const char* caller_name, VkQueueFlags flags,
@@ -812,8 +1088,7 @@ class CoreChecks : public ValidationStateTracker {
     bool InsideRenderPass(const CMD_BUFFER_STATE* pCB, const char* apiName, const char* msgCode) const;
     bool OutsideRenderPass(const CMD_BUFFER_STATE* pCB, const char* apiName, const char* msgCode) const;
 
-    void SetLayout(std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE>& imageLayoutMap, ImageSubresourcePair imgpair,
-                   VkImageLayout layout);
+    static void SetLayout(ImageSubresPairLayoutMap& imageLayoutMap, ImageSubresourcePair imgpair, VkImageLayout layout);
 
     bool ValidateImageSampleCount(const IMAGE_STATE* image_state, VkSampleCountFlagBits sample_count, const char* location,
                                   const std::string& msgCode) const;
@@ -825,16 +1100,22 @@ class CoreChecks : public ValidationStateTracker {
     bool ValidateDeviceMaskToZero(uint32_t deviceMask, VkDebugReportObjectTypeEXT VUID_handle_type, uint64_t VUID_handle,
                                   const char* VUID) const;
     bool ValidateDeviceMaskToCommandBuffer(const CMD_BUFFER_STATE* pCB, uint32_t deviceMask,
-                                           VkDebugReportObjectTypeEXT VUID_handle_type, uint64_t VUID_handle, const char* VUID);
+                                           VkDebugReportObjectTypeEXT VUID_handle_type, uint64_t VUID_handle,
+                                           const char* VUID) const;
     bool ValidateDeviceMaskToRenderPass(const CMD_BUFFER_STATE* pCB, uint32_t deviceMask,
                                         VkDebugReportObjectTypeEXT VUID_handle_type, uint64_t VUID_handle, const char* VUID);
 
+    bool ValidateBindAccelerationStructureMemoryNV(VkDevice device, const VkBindAccelerationStructureMemoryInfoNV& info) const;
     // Prototypes for CoreChecks accessor functions
     VkFormatProperties GetPDFormatProperties(const VkFormat format) const;
     VkResult GetPDImageFormatProperties(const VkImageCreateInfo*, VkImageFormatProperties*);
     VkResult GetPDImageFormatProperties2(const VkPhysicalDeviceImageFormatInfo2*, VkImageFormatProperties2*) const;
     const VkPhysicalDeviceMemoryProperties* GetPhysicalDeviceMemoryProperties();
 
+    const GlobalQFOTransferBarrierMap<VkImageMemoryBarrier>& GetGlobalQFOReleaseBarrierMap(
+        const QFOTransferBarrier<VkImageMemoryBarrier>::Tag& type_tag) const;
+    const GlobalQFOTransferBarrierMap<VkBufferMemoryBarrier>& GetGlobalQFOReleaseBarrierMap(
+        const QFOTransferBarrier<VkBufferMemoryBarrier>::Tag& type_tag) const;
     GlobalQFOTransferBarrierMap<VkImageMemoryBarrier>& GetGlobalQFOReleaseBarrierMap(
         const QFOTransferBarrier<VkImageMemoryBarrier>::Tag& type_tag);
     GlobalQFOTransferBarrierMap<VkBufferMemoryBarrier>& GetGlobalQFOReleaseBarrierMap(
@@ -842,13 +1123,13 @@ class CoreChecks : public ValidationStateTracker {
     template <typename Barrier>
     void RecordQueuedQFOTransferBarriers(CMD_BUFFER_STATE* cb_state);
     template <typename Barrier>
-    bool ValidateQueuedQFOTransferBarriers(CMD_BUFFER_STATE* cb_state, QFOTransferCBScoreboards<Barrier>* scoreboards);
-    bool ValidateQueuedQFOTransfers(CMD_BUFFER_STATE* cb_state,
+    bool ValidateQueuedQFOTransferBarriers(const CMD_BUFFER_STATE* cb_state, QFOTransferCBScoreboards<Barrier>* scoreboards) const;
+    bool ValidateQueuedQFOTransfers(const CMD_BUFFER_STATE* cb_state,
                                     QFOTransferCBScoreboards<VkImageMemoryBarrier>* qfo_image_scoreboards,
-                                    QFOTransferCBScoreboards<VkBufferMemoryBarrier>* qfo_buffer_scoreboards);
+                                    QFOTransferCBScoreboards<VkBufferMemoryBarrier>* qfo_buffer_scoreboards) const;
     template <typename BarrierRecord, typename Scoreboard>
     bool ValidateAndUpdateQFOScoreboard(const debug_report_data* report_data, const CMD_BUFFER_STATE* cb_state,
-                                        const char* operation, const BarrierRecord& barrier, Scoreboard* scoreboard);
+                                        const char* operation, const BarrierRecord& barrier, Scoreboard* scoreboard) const;
     template <typename Barrier>
     void RecordQFOTransferBarriers(CMD_BUFFER_STATE* cb_state, uint32_t barrier_count, const Barrier* barriers);
     void RecordBarriersQFOTransfers(CMD_BUFFER_STATE* cb_state, uint32_t bufferBarrierCount,
@@ -857,25 +1138,21 @@ class CoreChecks : public ValidationStateTracker {
     template <typename Barrier>
     bool ValidateQFOTransferBarrierUniqueness(const char* func_name, CMD_BUFFER_STATE* cb_state, uint32_t barrier_count,
                                               const Barrier* barriers);
-    bool IsReleaseOp(CMD_BUFFER_STATE* cb_state, VkImageMemoryBarrier const* barrier);
+    bool IsReleaseOp(CMD_BUFFER_STATE* cb_state, const VkImageMemoryBarrier& barrier) const;
     bool ValidateBarriersQFOTransferUniqueness(const char* func_name, CMD_BUFFER_STATE* cb_state, uint32_t bufferBarrierCount,
                                                const VkBufferMemoryBarrier* pBufferMemBarriers, uint32_t imageMemBarrierCount,
                                                const VkImageMemoryBarrier* pImageMemBarriers);
-    bool ValidatePrimaryCommandBufferState(CMD_BUFFER_STATE* pCB, int current_submit_count,
+    bool ValidatePrimaryCommandBufferState(const CMD_BUFFER_STATE* pCB, int current_submit_count,
                                            QFOTransferCBScoreboards<VkImageMemoryBarrier>* qfo_image_scoreboards,
-                                           QFOTransferCBScoreboards<VkBufferMemoryBarrier>* qfo_buffer_scoreboards);
-    bool ValidatePipelineDrawtimeState(LAST_BOUND_STATE const& state, const CMD_BUFFER_STATE* pCB, CMD_TYPE cmd_type,
-                                       PIPELINE_STATE const* pPipeline, const char* caller);
-    bool ValidateCmdBufDrawState(CMD_BUFFER_STATE* cb_node, CMD_TYPE cmd_type, const bool indexed,
+                                           QFOTransferCBScoreboards<VkBufferMemoryBarrier>* qfo_buffer_scoreboards) const;
+    bool ValidatePipelineDrawtimeState(const LAST_BOUND_STATE& state, const CMD_BUFFER_STATE* pCB, CMD_TYPE cmd_type,
+                                       const PIPELINE_STATE* pPipeline, const char* caller) const;
+    bool ValidateCmdBufDrawState(const CMD_BUFFER_STATE* cb_node, CMD_TYPE cmd_type, const bool indexed,
                                  const VkPipelineBindPoint bind_point, const char* function, const char* pipe_err_code,
-                                 const char* state_err_code);
-    void IncrementBoundObjects(CMD_BUFFER_STATE const* cb_node);
-    void IncrementResources(CMD_BUFFER_STATE* cb_node);
+                                 const char* state_err_code) const;
     bool ValidateEventStageMask(VkQueue queue, CMD_BUFFER_STATE* pCB, uint32_t eventCount, size_t firstEventIndex,
                                 VkPipelineStageFlags sourceStageMask);
-    void RetireWorkOnQueue(QUEUE_STATE* pQueue, uint64_t seq);
-    bool ValidateResources(CMD_BUFFER_STATE* cb_node);
-    bool ValidateQueueFamilyIndices(CMD_BUFFER_STATE* pCB, VkQueue queue);
+    bool ValidateQueueFamilyIndices(const CMD_BUFFER_STATE* pCB, VkQueue queue) const;
     VkResult CoreLayerCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo,
                                                const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);
     void CoreLayerDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache,
@@ -886,8 +1163,8 @@ class CoreChecks : public ValidationStateTracker {
                                                 void* pData);
     // For given bindings validate state at time of draw is correct, returning false on error and writing error details into string*
     bool ValidateDrawState(const cvdescriptorset::DescriptorSet* descriptor_set, const std::map<uint32_t, descriptor_req>& bindings,
-                           const std::vector<uint32_t>& dynamic_offsets, CMD_BUFFER_STATE* cb_node, const char* caller,
-                           std::string* error);
+                           const std::vector<uint32_t>& dynamic_offsets, const CMD_BUFFER_STATE* cb_node, const char* caller,
+                           std::string* error) const;
     // Validate contents of a CopyUpdate
     using DescriptorSet = cvdescriptorset::DescriptorSet;
     bool ValidateCopyUpdate(const VkCopyDescriptorSet* update, const DescriptorSet* dst_set, const DescriptorSet* src_set,
@@ -940,7 +1217,7 @@ class CoreChecks : public ValidationStateTracker {
     bool ValidateExecutionModes(SHADER_MODULE_STATE const* src, spirv_inst_iter entrypoint) const;
 
     // Gpu Validation Functions
-    void GpuPreCallRecordCreateDevice(VkPhysicalDevice gpu, std::unique_ptr<safe_VkDeviceCreateInfo>& modified_create_info,
+    void GpuPreCallRecordCreateDevice(VkPhysicalDevice gpu, safe_VkDeviceCreateInfo* modified_create_info,
                                       VkPhysicalDeviceFeatures* supported_features);
     void GpuPostCallRecordCreateDevice(const CHECK_ENABLED* enables, const VkDeviceCreateInfo* pCreateInfo);
     void GpuPreCallRecordDestroyDevice();
@@ -963,21 +1240,20 @@ class CoreChecks : public ValidationStateTracker {
                                                   const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
     void GpuPreCallRecordDestroyPipeline(const VkPipeline pipeline);
     void GpuAllocateValidationResources(const VkCommandBuffer cmd_buffer, VkPipelineBindPoint bind_point);
-    void AnalyzeAndReportError(CMD_BUFFER_STATE* cb_node, VkQueue queue, uint32_t draw_index, uint32_t* const debug_output_buffer);
+    void AnalyzeAndReportError(CMD_BUFFER_STATE* cb_node, VkQueue queue, VkPipelineBindPoint bind_point, uint32_t operation_index,
+                               uint32_t* const debug_output_buffer);
     void ProcessInstrumentationBuffer(VkQueue queue, CMD_BUFFER_STATE* cb_node);
     void UpdateInstrumentationBuffer(CMD_BUFFER_STATE* cb_node);
     void SubmitBarrier(VkQueue queue);
     bool GpuInstrumentShader(const VkShaderModuleCreateInfo* pCreateInfo, std::vector<unsigned int>& new_pgm,
                              uint32_t* unique_shader_id);
-    void GpuPreCallRecordPipelineCreations(uint32_t count, const VkGraphicsPipelineCreateInfo* pGraphicsCreateInfos,
-                                           const VkComputePipelineCreateInfo* pComputeCreateInfos,
-                                           const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
-                                           std::vector<std::unique_ptr<PIPELINE_STATE>>& pipe_state,
-                                           std::vector<safe_VkGraphicsPipelineCreateInfo>* new_graphics_pipeline_create_infos,
-                                           std::vector<safe_VkComputePipelineCreateInfo>* new_compute_pipeline_create_infos,
+    template <typename CreateInfo, typename SafeCreateInfo>
+    void GpuPreCallRecordPipelineCreations(uint32_t count, const CreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator,
+                                           VkPipeline* pPipelines, std::vector<std::unique_ptr<PIPELINE_STATE>>& pipe_state,
+                                           std::vector<SafeCreateInfo>* new_pipeline_create_infos,
                                            const VkPipelineBindPoint bind_point);
-    void GpuPostCallRecordPipelineCreations(const uint32_t count, const VkGraphicsPipelineCreateInfo* pGraphicsCreateInfos,
-                                            const VkComputePipelineCreateInfo* pComputeCreateInfos,
+    template <typename CreateInfo>
+    void GpuPostCallRecordPipelineCreations(const uint32_t count, const CreateInfo* pCreateInfos,
                                             const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
                                             const VkPipelineBindPoint bind_point);
     std::vector<safe_VkComputePipelineCreateInfo> GpuPreCallRecordCreateComputePipelines(
@@ -985,6 +1261,11 @@ class CoreChecks : public ValidationStateTracker {
         const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, std::vector<std::unique_ptr<PIPELINE_STATE>>& pipe_state);
     void GpuPostCallRecordCreateComputePipelines(const uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos,
                                                  const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+    std::vector<safe_VkRayTracingPipelineCreateInfoNV> GpuPreCallRecordCreateRayTracingPipelinesNV(
+        VkPipelineCache pipelineCache, uint32_t count, const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
+        const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, std::vector<std::unique_ptr<PIPELINE_STATE>>& pipe_state);
+    void GpuPostCallRecordCreateRayTracingPipelinesNV(const uint32_t count, const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
+                                                      const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
     VkResult GpuInitializeVma();
     void ReportSetupProblem(VkDebugReportObjectTypeEXT object_type, uint64_t object_handle, const char* const specific_message);
 
@@ -1020,7 +1301,7 @@ class CoreChecks : public ValidationStateTracker {
     bool ValidateRenderPassLayoutAgainstFramebufferImageUsage(RenderPassCreateVersion rp_version, VkImageLayout layout,
                                                               VkImage image, VkImageView image_view, VkFramebuffer framebuffer,
                                                               VkRenderPass renderpass, uint32_t attachment_index,
-                                                              const char* variable_name);
+                                                              const char* variable_name) const;
     bool ValidateBufferImageCopyData(uint32_t regionCount, const VkBufferImageCopy* pRegions, IMAGE_STATE* image_state,
                                      const char* function);
     bool ValidateBufferViewRange(const BUFFER_STATE* buffer_state, const VkBufferViewCreateInfo* pCreateInfo,
@@ -1074,10 +1355,6 @@ class CoreChecks : public ValidationStateTracker {
     VkExtent3D GetScaledItg(const CMD_BUFFER_STATE* cb_node, const IMAGE_STATE* img) const;
     bool CopyImageMultiplaneValidation(VkCommandBuffer command_buffer, const IMAGE_STATE* src_image_state,
                                        const IMAGE_STATE* dst_image_state, const VkImageCopy region) const;
-    void RecordRenderPassDAG(RenderPassCreateVersion rp_version, const VkRenderPassCreateInfo2KHR* pCreateInfo,
-                             RENDER_PASS_STATE* render_pass);
-    void RecordCreateRenderPassState(RenderPassCreateVersion rp_version, std::shared_ptr<RENDER_PASS_STATE>& render_pass,
-                                     VkRenderPass* pRenderPass);
 
     bool PreCallValidateCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout,
                                            const VkClearColorValue* pColor, uint32_t rangeCount,
@@ -1101,11 +1378,10 @@ class CoreChecks : public ValidationStateTracker {
 
     bool FindLayouts(VkImage image, std::vector<VkImageLayout>& layouts);
 
-    bool FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE>& imageLayoutMap,
-                    ImageSubresourcePair imgpair, VkImageLayout& layout);
+    bool FindLayout(const ImageSubresPairLayoutMap& imageLayoutMap, ImageSubresourcePair imgpair, VkImageLayout& layout) const;
 
-    bool FindLayout(const std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE>& imageLayoutMap,
-                    ImageSubresourcePair imgpair, VkImageLayout& layout, const VkImageAspectFlags aspectMask);
+    static bool FindLayout(const ImageSubresPairLayoutMap& imageLayoutMap, ImageSubresourcePair imgpair, VkImageLayout& layout,
+                           const VkImageAspectFlags aspectMask);
 
     void SetGlobalLayout(ImageSubresourcePair imgpair, const VkImageLayout& layout);
 
@@ -1119,10 +1395,11 @@ class CoreChecks : public ValidationStateTracker {
     void SetImageInitialLayout(CMD_BUFFER_STATE* cb_node, const IMAGE_STATE& image_state, const VkImageSubresourceLayers& layers,
                                VkImageLayout layout);
 
-    bool VerifyFramebufferAndRenderPassLayouts(RenderPassCreateVersion rp_version, CMD_BUFFER_STATE* pCB,
+    bool VerifyFramebufferAndRenderPassLayouts(RenderPassCreateVersion rp_version, const CMD_BUFFER_STATE* pCB,
                                                const VkRenderPassBeginInfo* pRenderPassBegin,
-                                               const FRAMEBUFFER_STATE* framebuffer_state);
-
+                                               const FRAMEBUFFER_STATE* framebuffer_state) const;
+    void RecordCmdBeginRenderPassLayouts(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
+                                         const VkSubpassContents contents);
     void TransitionAttachmentRefLayout(CMD_BUFFER_STATE* pCB, FRAMEBUFFER_STATE* pFramebuffer,
                                        const safe_VkAttachmentReference2KHR& ref);
 
@@ -1130,8 +1407,8 @@ class CoreChecks : public ValidationStateTracker {
 
     void TransitionBeginRenderPassLayouts(CMD_BUFFER_STATE*, const RENDER_PASS_STATE*, FRAMEBUFFER_STATE*);
 
-    bool ValidateBarrierLayoutToImageUsage(const VkImageMemoryBarrier* img_barrier, bool new_not_old, VkImageUsageFlags usage,
-                                           const char* func_name);
+    bool ValidateBarrierLayoutToImageUsage(const VkImageMemoryBarrier& img_barrier, bool new_not_old, VkImageUsageFlags usage,
+                                           const char* func_name, const char* barrier_pname);
 
     bool ValidateBarriersToImages(CMD_BUFFER_STATE const* cb_state, uint32_t imageMemoryBarrierCount,
                                   const VkImageMemoryBarrier* pImageMemoryBarriers, const char* func_name);
@@ -1150,6 +1427,8 @@ class CoreChecks : public ValidationStateTracker {
 
     bool PreCallValidateCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
                                             const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+    void PreCallRecordCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
+                                          const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
 
     bool PreCallValidateCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout,
                                         VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount,
@@ -1163,9 +1442,8 @@ class CoreChecks : public ValidationStateTracker {
                                    VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions,
                                    VkFilter filter);
 
-    bool ValidateCmdBufImageLayouts(CMD_BUFFER_STATE* pCB,
-                                    std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE> const& globalImageLayoutMap,
-                                    std::unordered_map<ImageSubresourcePair, IMAGE_LAYOUT_STATE>& overlayLayoutMap);
+    bool ValidateCmdBufImageLayouts(const CMD_BUFFER_STATE* pCB, const ImageSubresPairLayoutMap& globalImageLayoutMap,
+                                    ImageSubresPairLayoutMap* overlayLayoutMap_arg) const;
 
     void UpdateCmdBufImageLayouts(CMD_BUFFER_STATE* pCB);
 
@@ -1174,9 +1452,9 @@ class CoreChecks : public ValidationStateTracker {
 
     bool ValidateLayoutVsAttachmentDescription(const debug_report_data* report_data, RenderPassCreateVersion rp_version,
                                                const VkImageLayout first_layout, const uint32_t attachment,
-                                               const VkAttachmentDescription2KHR& attachment_description);
+                                               const VkAttachmentDescription2KHR& attachment_description) const;
 
-    bool ValidateLayouts(RenderPassCreateVersion rp_version, VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo);
+    bool ValidateLayouts(RenderPassCreateVersion rp_version, VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo) const;
 
     bool ValidateImageUsageFlags(IMAGE_STATE const* image_state, VkFlags desired, bool strict, const char* msgCode,
                                  char const* func_name, char const* usage_string) const;
@@ -1193,12 +1471,11 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo,
                                      const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
 
-
     bool PreCallValidateCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo,
                                          const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
 
     bool ValidateImageAspectMask(VkImage image, VkFormat format, VkImageAspectFlags aspect_mask, const char* func_name,
-                                 const char* vuid = "VUID-VkImageSubresource-aspectMask-parameter");
+                                 const char* vuid = "VUID-VkImageSubresource-aspectMask-parameter") const;
 
     bool ValidateCreateImageViewSubresourceRange(const IMAGE_STATE* image_state, bool is_imageview_2d_type,
                                                  const VkImageSubresourceRange& subresourceRange);
@@ -1217,7 +1494,7 @@ class CoreChecks : public ValidationStateTracker {
 
     bool ValidateCopyBufferImageTransferGranularityRequirements(const CMD_BUFFER_STATE* cb_node, const IMAGE_STATE* img,
                                                                 const VkBufferImageCopy* region, const uint32_t i,
-                                                                const char* function, const char* vuid);
+                                                                const char* function, const char* vuid) const;
 
     bool ValidateImageMipLevel(const CMD_BUFFER_STATE* cb_node, const IMAGE_STATE* img, uint32_t mip_level, const uint32_t i,
                                const char* function, const char* member, const char* vuid) const;
@@ -1258,16 +1535,13 @@ class CoreChecks : public ValidationStateTracker {
                                                   VkSubresourceLayout* pLayout);
     bool ValidateCreateImageANDROID(const debug_report_data* report_data, const VkImageCreateInfo* create_info);
     bool ValidateCreateImageViewANDROID(const VkImageViewCreateInfo* create_info);
-    bool ValidateGetImageSubresourceLayoutANDROID(const VkImage image);
+    bool ValidateGetImageSubresourceLayoutANDROID(const VkImage image) const;
     bool ValidateQueueFamilies(uint32_t queue_family_count, const uint32_t* queue_families, const char* cmd_name,
                                const char* array_parameter_name, const char* unique_error_code, const char* valid_error_code,
-                               bool optional);
+                               bool optional) const;
     bool ValidateAllocateMemoryANDROID(const VkMemoryAllocateInfo* alloc_info) const;
     bool ValidateGetImageMemoryRequirements2ANDROID(const VkImage image) const;
-    bool ValidateCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo* create_info);
-    void RecordCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo* create_info,
-                                                   VkSamplerYcbcrConversion ycbcr_conversion);
-    void RecordDestroySamplerYcbcrConversionANDROID(VkSamplerYcbcrConversion ycbcr_conversion);
+    bool ValidateCreateSamplerYcbcrConversionANDROID(const VkSamplerYcbcrConversionCreateInfo* create_info) const;
     bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
                                                 const VkGraphicsPipelineCreateInfo* pCreateInfos,
                                                 const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state);
@@ -1289,6 +1563,17 @@ class CoreChecks : public ValidationStateTracker {
                                               const VkComputePipelineCreateInfo* pCreateInfos,
                                               const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result,
                                               void* pipe_state);
+    bool PreCallValidateGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo,
+                                                           uint32_t* pExecutableCount,
+                                                           VkPipelineExecutablePropertiesKHR* pProperties);
+    bool ValidatePipelineExecutableInfo(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo) const;
+    bool PreCallValidateGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo,
+                                                           uint32_t* pStatisticCount,
+                                                           VkPipelineExecutableStatisticKHR* pStatistics);
+    bool PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(VkDevice device,
+                                                                        const VkPipelineExecutableInfoKHR* pExecutableInfo,
+                                                                        uint32_t* pInternalRepresentationCount,
+                                                                        VkPipelineExecutableInternalRepresentationKHR* pStatistics);
     bool PreCallValidateCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo,
                                              const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
     void PreCallRecordCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo,
@@ -1303,34 +1588,46 @@ class CoreChecks : public ValidationStateTracker {
                                                     const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
                                                     const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
                                                     void* pipe_state);
+    void PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                                  const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
+                                                  const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines,
+                                                  void* crtpl_state_data);
+    void PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t count,
+                                                   const VkRayTracingPipelineCreateInfoNV* pCreateInfos,
+                                                   const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result,
+                                                   void* crtpl_state_data);
+    void PreCallRecordCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+                                     VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+                                     VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+                                     VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+                                     VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+                                     VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+                                     uint32_t width, uint32_t height, uint32_t depth);
+    void PostCallRecordCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+                                      VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+                                      VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+                                      VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+                                      VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+                                      VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+                                      uint32_t width, uint32_t height, uint32_t depth);
     void PostCallRecordCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
                                       VkInstance* pInstance, VkResult result);
     bool PreCallValidateCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo,
                                      const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
     void PreCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo,
                                    const VkAllocationCallbacks* pAllocator, VkDevice* pDevice,
-                                   std::unique_ptr<safe_VkDeviceCreateInfo>& modified_create_info);
+                                   safe_VkDeviceCreateInfo* modified_create_info);
     void PostCallRecordCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo,
                                     const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, VkResult result);
     bool PreCallValidateCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                         VkDeviceSize dataSize, const void* pData);
-    void PostCallRecordCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
-                                   VkFence* pFence, VkResult result);
     bool PreCallValidateGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
-    void PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
-    void PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);
     bool PreCallValidateCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
                                                      const VkAllocationCallbacks* pAllocator,
                                                      VkSamplerYcbcrConversion* pYcbcrConversion);
-    void PostCallRecordCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
-                                                    const VkAllocationCallbacks* pAllocator,
-                                                    VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result);
     bool PreCallValidateCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
                                                         const VkAllocationCallbacks* pAllocator,
                                                         VkSamplerYcbcrConversion* pYcbcrConversion);
-    void PostCallRecordCreateSamplerYcbcrConversionKHR(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,
-                                                       const VkAllocationCallbacks* pAllocator,
-                                                       VkSamplerYcbcrConversion* pYcbcrConversion, VkResult result);
     bool PreCallValidateCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);
     void PreCallRecordDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
@@ -1350,46 +1647,20 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateDeviceWaitIdle(VkDevice device);
     void PostCallRecordDeviceWaitIdle(VkDevice device, VkResult result);
     bool PreCallValidateDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
+    bool ValidateGetQueryPoolResultsFlags(VkQueryPool queryPool, VkQueryResultFlags flags) const;
+    bool ValidateGetQueryPoolResultsQueries(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const;
     bool PreCallValidateGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount,
                                             size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
     bool PreCallValidateBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos);
-    void PostCallRecordBindBufferMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos,
-                                            VkResult result);
     bool PreCallValidateBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos);
-    void PostCallRecordBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos,
-                                         VkResult result);
     bool PreCallValidateBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset);
-    void PostCallRecordBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memoryOffset,
-                                        VkResult result);
-    void PostCallRecordGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
-    void PostCallRecordGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo,
-                                                    VkMemoryRequirements2KHR* pMemoryRequirements);
-    void PostCallRecordGetBufferMemoryRequirements2KHR(VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo,
-                                                       VkMemoryRequirements2KHR* pMemoryRequirements);
     bool PreCallValidateGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
                                                     VkMemoryRequirements2* pMemoryRequirements);
     bool PreCallValidateGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
                                                        VkMemoryRequirements2* pMemoryRequirements);
-    void PostCallRecordGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-    void PostCallRecordGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
-                                                   VkMemoryRequirements2* pMemoryRequirements);
-    void PostCallRecordGetImageMemoryRequirements2KHR(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo,
-                                                      VkMemoryRequirements2* pMemoryRequirements);
-    void PostCallRecordGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount,
-                                                        VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-    void PostCallRecordGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
-                                                         uint32_t* pSparseMemoryRequirementCount,
-                                                         VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
-    void PostCallRecordGetImageSparseMemoryRequirements2KHR(VkDevice device, const VkImageSparseMemoryRequirementsInfo2KHR* pInfo,
-                                                            uint32_t* pSparseMemoryRequirementCount,
-                                                            VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements);
     bool PreCallValidateGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice,
                                                                 const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,
                                                                 VkImageFormatProperties2* pImageFormatProperties);
@@ -1399,30 +1670,20 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
     void PreCallRecordDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                               const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount,
                                            const VkCommandBuffer* pCommandBuffers);
     bool PreCallValidateCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
                                           const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
-    void PostCallRecordCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo,
-                                         const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, VkResult result);
     bool PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
                                         const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
-    void PostCallRecordCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo,
-                                       const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, VkResult result);
     bool PreCallValidateDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
     bool PreCallValidateResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
     void PostCallRecordResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkResult result);
     bool PreCallValidateDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
-    void PostCallRecordCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo,
-                                     const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, VkResult result);
     bool PreCallValidateCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
                                                   const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
     bool PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
@@ -1431,8 +1692,6 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
                                              const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount,
                                              const VkCopyDescriptorSet* pDescriptorCopies);
-    void PostCallRecordAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pCreateInfo,
-                                              VkCommandBuffer* pCommandBuffer, VkResult result);
     bool PreCallValidateBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
     bool PreCallValidateEndCommandBuffer(VkCommandBuffer commandBuffer);
     bool PreCallValidateResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
@@ -1444,38 +1703,33 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor,
                                                  uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);
     bool PreCallValidateCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
-    void PreCallRecordCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);
     bool PreCallValidateCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport,
                                                            uint32_t viewportCount,
                                                            const VkShadingRatePaletteNV* pShadingRatePalettes);
-    void PostCallRecordCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo,
-                                                     const VkAllocationCallbacks* pAllocator,
-                                                     VkAccelerationStructureNV* pAccelerationStructure, VkResult result);
-    void PostCallRecordGetAccelerationStructureMemoryRequirementsNV(VkDevice device,
-                                                                    const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
-                                                                    VkMemoryRequirements2KHR* pMemoryRequirements);
+    bool ValidateGeometryTrianglesNV(const VkGeometryTrianglesNV& triangles, VkDebugReportObjectTypeEXT object_type,
+                                     uint64_t object_handle, const char* func_name) const;
+    bool ValidateGeometryAABBNV(const VkGeometryAABBNV& geometry, VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
+                                const char* func_name) const;
+    bool ValidateGeometryNV(const VkGeometryNV& geometry, VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
+                            const char* func_name) const;
+    bool PreCallValidateCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo,
+                                                      const VkAllocationCallbacks* pAllocator,
+                                                      VkAccelerationStructureNV* pAccelerationStructure);
     bool PreCallValidateBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
                                                           const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);
-    void PostCallRecordBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount,
-                                                         const VkBindAccelerationStructureMemoryInfoNV* pBindInfos,
-                                                         VkResult result);
+    bool PreCallValidateGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
+                                                         size_t dataSize, void* pData);
     bool PreCallValidateCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo,
                                                         VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update,
                                                         VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
                                                         VkBuffer scratch, VkDeviceSize scratchOffset);
-    void PostCallRecordCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo,
-                                                       VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update,
-                                                       VkAccelerationStructureNV dst, VkAccelerationStructureNV src,
-                                                       VkBuffer scratch, VkDeviceSize scratchOffset);
     bool PreCallValidateCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
                                                        VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode);
-    void PostCallRecordCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst,
-                                                      VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode);
     bool PreCallValidateDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
                                                        const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure,
-                                                     const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth);
+    bool PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                             uint16_t lineStipplePattern);
     bool PreCallValidateCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp,
                                         float depthBiasSlopeFactor);
     bool PreCallValidateCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]);
@@ -1495,45 +1749,31 @@ class CoreChecks : public ValidationStateTracker {
                                               const VkWriteDescriptorSet* pDescriptorWrites);
     bool PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                            VkIndexType indexType);
-    void PreCallRecordCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                         VkIndexType indexType);
     bool PreCallValidateCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
                                              const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-    void PreCallRecordCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount,
-                                           const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
     bool PreCallValidateCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
                                 uint32_t firstInstance);
     void PreCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
                               uint32_t firstInstance);
-    void PostCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex,
-                               uint32_t firstInstance);
     bool PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
                                        uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
     void PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
                                      uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-    void PostCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
-                                      uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
     bool PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
                                                uint32_t stride);
     void PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
                                              uint32_t stride);
-    void PostCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
-                                              uint32_t stride);
     bool PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                        VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                        uint32_t stride);
     bool PreCallValidateCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
     void PreCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
-    void PostCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
     bool PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
     void PreCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
-    void PostCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
     bool PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
                                         uint32_t stride);
     void PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
                                       uint32_t stride);
-    void PostCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
-                                       uint32_t stride);
     bool PreCallValidateCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
     void PreCallRecordCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
     bool PreCallValidateCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
@@ -1563,20 +1803,19 @@ class CoreChecks : public ValidationStateTracker {
                                          uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers,
                                          uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers,
                                          uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+
+    void EnqueueVerifyBeginQuery(VkCommandBuffer, const QueryObject& query_obj);
     bool PreCallValidateCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags);
-    void PostCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags);
+    void PreCallRecordCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags);
     bool PreCallValidateCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot);
-    void PostCallRecordCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot);
     bool PreCallValidateCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
                                           uint32_t queryCount);
-    void PostCallRecordCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
-                                         uint32_t queryCount);
     bool PreCallValidateCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
                                                 uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset,
                                                 VkDeviceSize stride, VkQueryResultFlags flags);
-    void PostCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
-                                               uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride,
-                                               VkQueryResultFlags flags);
+    void PreCallRecordCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery,
+                                              uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride,
+                                              VkQueryResultFlags flags);
     bool PreCallValidateCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags,
                                          uint32_t offset, uint32_t size, const void* pValues);
     bool PreCallValidateCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage,
@@ -1585,17 +1824,11 @@ class CoreChecks : public ValidationStateTracker {
                                          VkQueryPool queryPool, uint32_t slot);
     bool PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
                                           const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
-    void PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo,
-                                         const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, VkResult result);
     bool PreCallValidateCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
                                          const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
-    void PostCallRecordCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo,
-                                        const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result);
     bool PreCallValidateGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory mem, VkDeviceSize* pCommittedMem);
     bool PreCallValidateCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo,
                                              const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
-    void PostCallRecordCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateInfo2KHR* pCreateInfo,
-                                            const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass, VkResult result);
     bool PreCallValidateCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
                                            VkSubpassContents contents);
     void PreCallRecordCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin,
@@ -1616,8 +1849,6 @@ class CoreChecks : public ValidationStateTracker {
     void PostCallRecordCmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo);
     bool PreCallValidateCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
                                            const VkCommandBuffer* pCommandBuffers);
-    void PreCallRecordCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount,
-                                         const VkCommandBuffer* pCommandBuffers);
     bool PreCallValidateMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags,
                                   void** ppData);
     void PostCallRecordMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags,
@@ -1630,21 +1861,13 @@ class CoreChecks : public ValidationStateTracker {
     void PostCallRecordInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges,
                                                     VkResult result);
     bool PreCallValidateBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset);
-    void PostCallRecordBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memoryOffset,
-                                       VkResult result);
     bool PreCallValidateBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos);
-    void PostCallRecordBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos,
-                                        VkResult result);
     bool PreCallValidateBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos);
-    void PostCallRecordBindImageMemory2KHR(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos,
-                                           VkResult result);
     bool PreCallValidateSetEvent(VkDevice device, VkEvent event);
     void PreCallRecordSetEvent(VkDevice device, VkEvent event);
     bool PreCallValidateQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
     void PostCallRecordQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence,
                                        VkResult result);
-    void PostCallRecordCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo,
-                                       const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, VkResult result);
     bool PreCallValidateImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);
     void PostCallRecordImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo,
                                             VkResult result);
@@ -1669,12 +1892,8 @@ class CoreChecks : public ValidationStateTracker {
 
     void PostCallRecordGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result);
     void PostCallRecordGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd, VkResult result);
-    void PostCallRecordCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
-                                   VkEvent* pEvent, VkResult result);
     bool PreCallValidateCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
                                            const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
-    void PostCallRecordCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo,
-                                          const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain, VkResult result);
     void PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount,
                                               VkImage* pSwapchainImages);
@@ -1685,65 +1904,22 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
                                                   const VkSwapchainCreateInfoKHR* pCreateInfos,
                                                   const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);
-    void PostCallRecordCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount,
-                                                 const VkSwapchainCreateInfoKHR* pCreateInfos,
-                                                 const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains,
-                                                 VkResult result);
     bool PreCallValidateAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore,
                                             VkFence fence, uint32_t* pImageIndex);
     bool PreCallValidateAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);
-    void PostCallRecordAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore,
-                                           VkFence fence, uint32_t* pImageIndex, VkResult result);
-    void PostCallRecordAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex,
-                                            VkResult result);
-    void PostCallRecordEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount,
-                                                VkPhysicalDevice* pPhysicalDevices, VkResult result);
     bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
                                                                VkQueueFamilyProperties* pQueueFamilyProperties);
-    void PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
-                                                              VkQueueFamilyProperties* pQueueFamilyProperties);
     bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
                                                                 uint32_t* pQueueFamilyPropertyCount,
                                                                 VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
-    void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount,
-                                                               VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
     bool PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
                                                                    uint32_t* pQueueFamilyPropertyCount,
                                                                    VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
-    void PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice,
-                                                                  uint32_t* pQueueFamilyPropertyCount,
-                                                                  VkQueueFamilyProperties2KHR* pQueueFamilyProperties);
     bool PreCallValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
-    void PreCallRecordValidateDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
-    void PostCallRecordGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                               VkSurfaceCapabilitiesKHR* pSurfaceCapabilities, VkResult result);
-    void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice,
-                                                                const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
-                                                                VkSurfaceCapabilities2KHR* pSurfaceCapabilities, VkResult result);
-    void PostCallRecordGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                                VkSurfaceCapabilities2EXT* pSurfaceCapabilities, VkResult result);
     bool PreCallValidateGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
                                                            VkSurfaceKHR surface, VkBool32* pSupported);
-    void PostCallRecordGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
-                                                          VkSurfaceKHR surface, VkBool32* pSupported, VkResult result);
-    void PostCallRecordGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                               uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes,
-                                                               VkResult result);
     bool PreCallValidateGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
                                                            uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
-    void PostCallRecordGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface,
-                                                          uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats,
-                                                          VkResult result);
-    void PostCallRecordGetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice,
-                                                           const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,
-                                                           uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats,
-                                                           VkResult result);
-    void PostCallRecordCreateDisplayPlaneSurfaceKHR(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,
-                                                    const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface,
-                                                    VkResult result);
-    void PreCallRecordCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
-    void PostCallRecordCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer);
-    void PreCallRecordCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);
     bool PreCallValidateCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo,
                                                        const VkAllocationCallbacks* pAllocator,
                                                        VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate);
@@ -1763,10 +1939,6 @@ class CoreChecks : public ValidationStateTracker {
     void PreCallRecordCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
                                                           VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
                                                           VkPipelineLayout layout, uint32_t set, const void* pData);
-    void PostCallRecordGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
-                                                                  VkDisplayPlanePropertiesKHR* pProperties, VkResult result);
-    void PostCallRecordGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount,
-                                                                   VkDisplayPlaneProperties2KHR* pProperties, VkResult result);
     bool PreCallValidateGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex,
                                                             uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
     bool PreCallValidateGetDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex,
@@ -1778,10 +1950,9 @@ class CoreChecks : public ValidationStateTracker {
 
     bool PreCallValidateCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
                                                 VkQueryControlFlags flags, uint32_t index);
-    void PostCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
-                                               VkQueryControlFlags flags, uint32_t index);
+    void PreCallRecordCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query,
+                                              VkQueryControlFlags flags, uint32_t index);
     bool PreCallValidateCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
-    void PostCallRecordCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);
 
     bool PreCallValidateCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle,
                                                   uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);
@@ -1790,48 +1961,31 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                 VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                 uint32_t stride);
-    void PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                              VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
-                                              uint32_t stride);
-    void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                     VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
-                                                     uint32_t stride);
     bool PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
-    void PreCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);
     bool PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                    uint32_t drawCount, uint32_t stride);
-    void PreCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                 uint32_t drawCount, uint32_t stride);
     bool PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
                                                         VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
                                                         uint32_t stride);
-    void PreCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                      VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
-                                                      uint32_t stride);
-    void PostCallRecordDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-                                                     const VkAllocationCallbacks* pAllocator);
     void PreCallRecordGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
                                                   VkPhysicalDeviceProperties* pPhysicalDeviceProperties);
-    void PostCallRecordDestroySamplerYcbcrConversionKHR(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion,
-                                                        const VkAllocationCallbacks* pAllocator);
     bool PreCallValidateGetBufferDeviceAddressEXT(VkDevice device, const VkBufferDeviceAddressInfoEXT* pInfo);
     bool PreCallValidateCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask);
     bool ValidateComputeWorkGroupSizes(const SHADER_MODULE_STATE* shader) const;
 
     bool ValidateQueryRange(VkDevice device, VkQueryPool queryPool, uint32_t totalCount, uint32_t firstQuery, uint32_t queryCount,
-                            const char* vuid_badfirst, const char* vuid_badrange);
+                            const char* vuid_badfirst, const char* vuid_badrange) const;
     bool PreCallValidateResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
-    void PostCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
 
     bool ValidateComputeWorkGroupInvocations(CMD_BUFFER_STATE* cb_state, uint32_t groupCountX, uint32_t groupCountY,
                                              uint32_t groupCountZ);
     bool ValidateQueryPoolStride(const std::string& vuid_not_64, const std::string& vuid_64, const VkDeviceSize stride,
-                                 const char* parameter_name, const uint64_t parameter_value, const VkQueryResultFlags flags);
+                                 const char* parameter_name, const uint64_t parameter_value, const VkQueryResultFlags flags) const;
     bool ValidateCmdDrawStrideWithStruct(VkCommandBuffer commandBuffer, const std::string& vuid, const uint32_t stride,
-                                         const char* struct_name, const uint32_t struct_size);
+                                         const char* struct_name, const uint32_t struct_size) const;
     bool ValidateCmdDrawStrideWithBuffer(VkCommandBuffer commandBuffer, const std::string& vuid, const uint32_t stride,
                                          const char* struct_name, const uint32_t struct_size, const uint32_t drawCount,
-                                         const VkDeviceSize offset, const BUFFER_STATE* buffer_state);
+                                         const VkDeviceSize offset, const BUFFER_STATE* buffer_state) const;
 
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
     bool PreCallValidateGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer,
@@ -1842,39 +1996,21 @@ class CoreChecks : public ValidationStateTracker {
     bool PreCallValidateGetMemoryAndroidHardwareBufferANDROID(VkDevice device,
                                                               const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
                                                               struct AHardwareBuffer** pBuffer);
-    void PostCallRecordCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo,
-                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
 #endif  // VK_USE_PLATFORM_ANDROID_KHR
-#ifdef VK_USE_PLATFORM_IOS_MVK
-    void PostCallRecordCreateIOSSurfaceMVK(VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo,
-                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
-#endif  // VK_USE_PLATFORM_IOS_MVK
-#ifdef VK_USE_PLATFORM_MACOS_MVK
-    void PostCallRecordCreateMacOSSurfaceMVK(VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo,
-                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
-#endif  // VK_USE_PLATFORM_MACOS_MVK
 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
     bool PreCallValidateGetPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
                                                                        struct wl_display* display);
-    void PostCallRecordCreateWaylandSurfaceKHR(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo,
-                                               const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
 #endif  // VK_USE_PLATFORM_WAYLAND_KHR
 #ifdef VK_USE_PLATFORM_WIN32_KHR
     bool PreCallValidateGetPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);
-    void PostCallRecordCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo,
-                                             const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
 #ifdef VK_USE_PLATFORM_XCB_KHR
     bool PreCallValidateGetPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
                                                                    xcb_connection_t* connection, xcb_visualid_t visual_id);
-    void PostCallRecordCreateXcbSurfaceKHR(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo,
-                                           const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
 #endif  // VK_USE_PLATFORM_XCB_KHR
 #ifdef VK_USE_PLATFORM_XLIB_KHR
     bool PreCallValidateGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex,
                                                                     Display* dpy, VisualID visualID);
-    void PostCallRecordCreateXlibSurfaceKHR(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
-                                            const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result);
 #endif  // VK_USE_PLATFORM_XLIB_KHR
 
 };  // Class CoreChecks
diff --git a/layers/core_validation_error_enums.h b/layers/core_validation_error_enums.h
index 45e9e7288..f3fe510e7 100644
--- a/layers/core_validation_error_enums.h
+++ b/layers/core_validation_error_enums.h
@@ -36,7 +36,6 @@
 
 static const char DECORATE_UNUSED *kVUID_Core_MemTrack_FenceState = "UNASSIGNED-CoreValidation-MemTrack-FenceState";
 static const char DECORATE_UNUSED *kVUID_Core_MemTrack_FreedMemRef = "UNASSIGNED-CoreValidation-MemTrack-FreedMemRef";
-static const char DECORATE_UNUSED *kVUID_Core_MemTrack_InvalidAliasing = "UNASSIGNED-CoreValidation-MemTrack-InvalidAliasing";
 static const char DECORATE_UNUSED *kVUID_Core_MemTrack_InvalidMap = "UNASSIGNED-CoreValidation-MemTrack-InvalidMap";
 static const char DECORATE_UNUSED *kVUID_Core_MemTrack_InvalidState = "UNASSIGNED-CoreValidation-MemTrack-InvalidState";
 static const char DECORATE_UNUSED *kVUID_Core_MemTrack_InvalidUsageFlag = "UNASSIGNED-CoreValidation-MemTrack-InvalidUsageFlag";
@@ -51,6 +50,7 @@ static const char DECORATE_UNUSED *kVUID_Core_MemTrack_RebindObject = "UNASSIGNE
 //static const char DECORATE_UNUSED *kVUID_Core_MemTrack_MemoryLeak = "UNASSIGNED-CoreValidation-MemTrack-MemoryLeak";
 //static const char DECORATE_UNUSED *kVUID_Core_MemTrack_ObjNotBound = "UNASSIGNED-CoreValidation-MemTrack-ObjNotBound";
 //static const char DECORATE_UNUSED *kVUID_Core_MemTrack_ResetCBWhileInFlight = "UNASSIGNED-CoreValidation-MemTrack-ResetCBWhileInFlight";
+//static const char DECORATE_UNUSED *kVUID_Core_MemTrack_InvalidAliasing = "UNASSIGNED-CoreValidation-MemTrack-InvalidAliasing";
 
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_ClearCmdBeforeDraw = "UNASSIGNED-CoreValidation-DrawState-ClearCmdBeforeDraw";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_CommandBufferSingleSubmitViolation = "UNASSIGNED-CoreValidation-DrawState-CommandBufferSingleSubmitViolation";
@@ -60,7 +60,7 @@ static const char DECORATE_UNUSED *kVUID_Core_DrawState_DoubleDestroy = "UNASSIG
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_ExtensionNotEnabled = "UNASSIGNED-CoreValidation-DrawState-ExtensionNotEnabled";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InternalError = "UNASSIGNED-CoreValidation-DrawState-InternalError";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidBarrier = "UNASSIGNED-CoreValidation-DrawState-InvalidBarrier";
-static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidBuffer = "UNASSIGNED-CoreValidation-DrawState-InvalidBuffer";
+//static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidBuffer = "UNASSIGNED-CoreValidation-DrawState-InvalidBuffer";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidCommandBuffer = "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBuffer";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidCommandBufferSimultaneousUse = "UNASSIGNED-CoreValidation-DrawState-InvalidCommandBufferSimultaneousUse";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidDescriptorSet = "UNASSIGNED-CoreValidation-DrawState-InvalidDescriptorSet";
@@ -68,7 +68,7 @@ static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidEvent = "UNASSIGN
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidExtents = "UNASSIGNED-CoreValidation-DrawState-InvalidExtents";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidFeature = "UNASSIGNED-CoreValidation-DrawState-InvalidFeature";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidFence = "UNASSIGNED-CoreValidation-DrawState-InvalidFence";
-static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidImage = "UNASSIGNED-CoreValidation-DrawState-InvalidImage";
+//static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidImage = "UNASSIGNED-CoreValidation-DrawState-InvalidImage";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidImageAspect = "UNASSIGNED-CoreValidation-DrawState-InvalidImageAspect";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidImageLayout = "UNASSIGNED-CoreValidation-DrawState-InvalidImageLayout";
 static const char DECORATE_UNUSED *kVUID_Core_DrawState_InvalidLayout = "UNASSIGNED-CoreValidation-DrawState-InvalidLayout";
@@ -239,6 +239,13 @@ static const char DECORATE_UNUSED *kVUID_Core_PushDescriptorUpdate_TemplateType
 static const char DECORATE_UNUSED *kVUID_Core_PushDescriptorUpdate_Template_SetMismatched = "UNASSIGNED-CoreValidation-vkCmdPushDescriptorSetWithTemplateKHR-set";
 static const char DECORATE_UNUSED *kVUID_Core_PushDescriptorUpdate_Template_LayoutMismatched = "UNASSIGNED-CoreValidation-vkCmdPushDescriptorSetWithTemplateKHR-layout";
 
+static const char DECORATE_UNUSED *kVUID_Core_BindImage_InvalidMemReqQuery = "UNASSIGNED-CoreValidation-vkBindImageMemory-invalid-requirements";
+static const char DECORATE_UNUSED *kVUID_Core_BindImage_NoMemReqQuery = "UNASSIGNED-CoreValidation-vkBindImageMemory-memory-requirements";
+static const char DECORATE_UNUSED *kVUID_Core_BindBuffer_NoMemReqQuery = "UNASSIGNED-CoreValidation-vkBindBufferMemory-memory-requirements";
+
+static const char DECORATE_UNUSED *kVUID_Core_BindAccelNV_NoMemReqQuery = "UNASSIGNED-CoreValidation-vkBindAccelerationStructureMemoryNV-object-requirements";
+static const char DECORATE_UNUSED *kVUID_Core_CmdBuildAccelNV_NoScratchMemReqQuery = "UNASSIGNED-CoreValidation-vkCmdBuildAccelerationStructureNV-scratch-requirements";
+static const char DECORATE_UNUSED *kVUID_Core_CmdBuildAccelNV_NoUpdateMemReqQuery = "UNASSIGNED-CoreValidation-vkCmdBuildAccelerationStructureNV-update-requirements";
 // clang-format on
 
 #undef DECORATE_UNUSED
diff --git a/layers/core_validation_types.h b/layers/core_validation_types.h
index f1689919e..f4b2239e1 100644
--- a/layers/core_validation_types.h
+++ b/layers/core_validation_types.h
@@ -146,6 +146,10 @@ enum descriptor_req {
     DESCRIPTOR_REQ_COMPONENT_TYPE_UINT = DESCRIPTOR_REQ_COMPONENT_TYPE_SINT << 1,
 };
 
+extern unsigned DescriptorRequirementsBitsFromFormat(VkFormat fmt);
+
+typedef std::map<uint32_t, descriptor_req> BindingReqMap;
+
 struct DESCRIPTOR_POOL_STATE : BASE_NODE {
     VkDescriptorPool pool;
     uint32_t maxSets;        // Max descriptor sets allowed in this pool
@@ -327,6 +331,8 @@ class IMAGE_VIEW_STATE : public BASE_NODE {
     VkImageView image_view;
     VkImageViewCreateInfo create_info;
     VkImageSubresourceRange normalized_subresource_range;
+    VkSampleCountFlagBits samples;
+    unsigned descriptor_format_bits;
     VkSamplerYcbcrConversion samplerConversion;  // Handle of the ycbcr sampler conversion the image was created with, if any
     IMAGE_VIEW_STATE(const IMAGE_STATE *image_state, VkImageView iv, const VkImageViewCreateInfo *ci);
     IMAGE_VIEW_STATE(const IMAGE_VIEW_STATE &rh_obj) = delete;
@@ -358,26 +364,6 @@ struct MemRange {
     VkDeviceSize size;
 };
 
-struct MEMORY_RANGE {
-    uint64_t handle;
-    bool image;   // True for image, false for buffer
-    bool linear;  // True for buffers and linear images
-    VkDeviceMemory memory;
-    VkDeviceSize start;
-    VkDeviceSize size;
-    VkDeviceSize end;  // Store this pre-computed for simplicity
-    // Set of ptrs to every range aliased with this one
-    std::unordered_set<MEMORY_RANGE *> aliases;
-};
-
-static inline VulkanTypedHandle MemoryRangeTypedHandle(const MEMORY_RANGE &range) {
-    // TODO: Convert MEMORY_RANGE to use VulkanTypedHandle internally
-    if (range.image) {
-        return VulkanTypedHandle(CastFromUint64<VkImage>(range.handle), kVulkanObjectTypeImage);
-    }
-    return VulkanTypedHandle(CastFromUint64<VkBuffer>(range.handle), kVulkanObjectTypeBuffer);
-}
-
 // Data struct for tracking memory object
 struct DEVICE_MEMORY_STATE : public BASE_NODE {
     void *object;  // Dispatchable object used to create this memory (device of swapchain)
@@ -388,8 +374,7 @@ struct DEVICE_MEMORY_STATE : public BASE_NODE {
     VkImage dedicated_image;
     bool is_export;
     VkExternalMemoryHandleTypeFlags export_handle_type_flags;
-    std::unordered_set<VulkanTypedHandle> obj_bindings;       // objects bound to this memory
-    std::unordered_map<uint64_t, MEMORY_RANGE> bound_ranges;  // Map of object to its binding range
+    std::unordered_set<VulkanTypedHandle> obj_bindings;  // objects bound to this memory
     // Convenience vectors of handles to speed up iterating over objects independently
     std::unordered_set<uint64_t> bound_images;
     std::unordered_set<uint64_t> bound_buffers;
@@ -829,8 +814,8 @@ class ImageSubresourceLayoutMapImpl : public ImageSubresourceLayoutMap {
         return subres;
     }
 
-    uint32_t LevelLimit(uint32_t level) const { return std::min(image_state_.full_range.levelCount, level); }
-    uint32_t LayerLimit(uint32_t layer) const { return std::min(image_state_.full_range.layerCount, layer); }
+    uint32_t LevelLimit(uint32_t level) const { return (std::min)(image_state_.full_range.levelCount, level); }
+    uint32_t LayerLimit(uint32_t layer) const { return (std::min)(image_state_.full_range.layerCount, layer); }
 
     bool InRange(const VkImageSubresource &subres) const {
         bool in_range = (subres.mipLevel < image_state_.full_range.levelCount) &&
@@ -987,7 +972,8 @@ enum CBStatusFlagBits {
     CBSTATUS_INDEX_BUFFER_BOUND     = 0x00000200,   // Index buffer has been set
     CBSTATUS_EXCLUSIVE_SCISSOR_SET  = 0x00000400,
     CBSTATUS_SHADING_RATE_PALETTE_SET = 0x00000800,
-    CBSTATUS_ALL_STATE_SET          = 0x00000DFF,   // All state set (intentionally exclude index buffer)
+    CBSTATUS_LINE_STIPPLE_SET       = 0x00001000,
+    CBSTATUS_ALL_STATE_SET          = 0x00001DFF,   // All state set (intentionally exclude index buffer)
     // clang-format on
 };
 
@@ -1006,6 +992,7 @@ enum QueryState {
     QUERYSTATE_UNKNOWN,    // Initial state.
     QUERYSTATE_RESET,      // After resetting.
     QUERYSTATE_RUNNING,    // Query running.
+    QUERYSTATE_ENDED,      // Query ended but results may not be available.
     QUERYSTATE_AVAILABLE,  // Results available.
 };
 
@@ -1049,7 +1036,7 @@ struct hash<QueryObject> {
 };
 }  // namespace std
 
-struct DrawData {
+struct CBVertexBufferBindingInfo {
     std::vector<BufferBinding> vertex_buffer_bindings;
 };
 
@@ -1128,19 +1115,6 @@ struct PIPELINE_LAYOUT_STATE {
         compat_for_set.clear();
     }
 };
-
-static inline bool CompatForSet(uint32_t set, const std::vector<PipelineLayoutCompatId> &a,
-                                const std::vector<PipelineLayoutCompatId> &b) {
-    bool result = (set < a.size()) && (set < b.size()) && (a[set] == b[set]);
-    return result;
-}
-
-static inline bool CompatForSet(uint32_t set, const PIPELINE_LAYOUT_STATE *a, const PIPELINE_LAYOUT_STATE *b) {
-    // Intentionally have a result variable to simplify debugging
-    bool result = a && b && CompatForSet(set, a->compat_for_set, b->compat_for_set);
-    return result;
-}
-
 // Shader typedefs needed to store StageStage below
 struct interface_var {
     uint32_t id;
@@ -1171,7 +1145,7 @@ class PIPELINE_STATE : public BASE_NODE {
     uint32_t active_shaders;
     uint32_t duplicate_shaders;
     // Capture which slots (set#->bindings) are actually used by the shaders of this pipeline
-    std::unordered_map<uint32_t, std::map<uint32_t, descriptor_req>> active_slots;
+    std::unordered_map<uint32_t, BindingReqMap> active_slots;
     // Additional metadata needed by pipeline_state initialization and validation
     std::vector<StageState> stage_state;
     // Vtx input info (if any)
@@ -1226,6 +1200,17 @@ class PIPELINE_STATE : public BASE_NODE {
         else
             return VK_PIPELINE_BIND_POINT_MAX_ENUM;
     }
+
+    inline VkPipelineCreateFlags getPipelineCreateFlags() const {
+        if (graphicsPipelineCI.sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
+            return graphicsPipelineCI.flags;
+        else if (computePipelineCI.sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO)
+            return computePipelineCI.flags;
+        else if (raytracingPipelineCI.sType == VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV)
+            return raytracingPipelineCI.flags;
+        else
+            return 0;
+    }
 };
 
 // Track last states that are bound per pipeline bind point (Gfx & Compute)
@@ -1233,28 +1218,44 @@ struct LAST_BOUND_STATE {
     LAST_BOUND_STATE() { reset(); }  // must define default constructor for portability reasons
     PIPELINE_STATE *pipeline_state;
     VkPipelineLayout pipeline_layout;
-    // Track each set that has been bound
-    // Ordered bound set tracking where index is set# that given set is bound to
-    std::vector<cvdescriptorset::DescriptorSet *> boundDescriptorSets;
     std::unique_ptr<cvdescriptorset::DescriptorSet> push_descriptor_set;
-    // one dynamic offset per dynamic descriptor bound to this CB
-    std::vector<std::vector<uint32_t>> dynamicOffsets;
-    std::vector<PipelineLayoutCompatId> compat_id_for_set;
+
+    // Ordered bound set tracking where index is set# that given set is bound to
+    struct PER_SET {
+        PER_SET()
+            : bound_descriptor_set(nullptr),
+              compat_id_for_set(0),
+              validated_set(nullptr),
+              validated_set_change_count(~0ULL),
+              validated_set_image_layout_change_count(~0ULL),
+              validated_set_binding_req_map() {}
+
+        cvdescriptorset::DescriptorSet *bound_descriptor_set;
+        // one dynamic offset per dynamic descriptor bound to this CB
+        std::vector<uint32_t> dynamicOffsets;
+        PipelineLayoutCompatId compat_id_for_set;
+
+        // Cache most recently validated descriptor state for ValidateCmdBufDrawState/UpdateDrawState
+        const cvdescriptorset::DescriptorSet *validated_set;
+        uint64_t validated_set_change_count;
+        uint64_t validated_set_image_layout_change_count;
+        BindingReqMap validated_set_binding_req_map;
+    };
+
+    std::vector<PER_SET> per_set;
 
     void reset() {
         pipeline_state = nullptr;
         pipeline_layout = VK_NULL_HANDLE;
-        boundDescriptorSets.clear();
         push_descriptor_set = nullptr;
-        dynamicOffsets.clear();
-        compat_id_for_set.clear();
+        per_set.clear();
     }
 
     void UnbindAndResetPushDescriptorSet(cvdescriptorset::DescriptorSet *ds) {
         if (push_descriptor_set) {
-            for (std::size_t i = 0; i < boundDescriptorSets.size(); i++) {
-                if (boundDescriptorSets[i] == push_descriptor_set.get()) {
-                    boundDescriptorSets[i] = nullptr;
+            for (std::size_t i = 0; i < per_set.size(); i++) {
+                if (per_set[i].bound_descriptor_set == push_descriptor_set.get()) {
+                    per_set[i].bound_descriptor_set = nullptr;
                 }
             }
         }
@@ -1262,6 +1263,18 @@ struct LAST_BOUND_STATE {
     }
 };
 
+static inline bool CompatForSet(uint32_t set, const LAST_BOUND_STATE &a, const std::vector<PipelineLayoutCompatId> &b) {
+    bool result = (set < a.per_set.size()) && (set < b.size()) && (a.per_set[set].compat_id_for_set == b[set]);
+    return result;
+}
+
+static inline bool CompatForSet(uint32_t set, const PIPELINE_LAYOUT_STATE *a, const PIPELINE_LAYOUT_STATE *b) {
+    // Intentionally have a result variable to simplify debugging
+    bool result = a && b && (set < a->compat_for_set.size()) && (set < b->compat_for_set.size()) &&
+                  (a->compat_for_set[set] == b->compat_for_set[set]);
+    return result;
+}
+
 // Types to store queue family ownership (QFO) Transfers
 
 // Common to image and buffer memory barriers
@@ -1398,6 +1411,8 @@ struct CMD_BUFFER_STATE : public BASE_NODE {
     VkCommandBufferInheritanceInfo inheritanceInfo;
     VkDevice device;  // device this CB belongs to
     bool hasDrawCmd;
+    bool hasTraceRaysCmd;
+    bool hasDispatchCmd;
     CB_STATE state;        // Track cmd buffer update state
     uint64_t submitCount;  // Number of times CB has been submitted
     typedef uint64_t ImageLayoutUpdateCount;
@@ -1439,20 +1454,17 @@ struct CMD_BUFFER_STATE : public BASE_NODE {
     typedef std::unordered_map<VkImage, std::unique_ptr<ImageSubresourceLayoutMap>> ImageLayoutMap;
     ImageLayoutMap image_layout_map;
     std::unordered_map<VkEvent, VkPipelineStageFlags> eventToStageMap;
-    std::vector<DrawData> draw_data;
-    DrawData current_draw_data;
+    std::vector<CBVertexBufferBindingInfo> cb_vertex_buffer_binding_info;
+    CBVertexBufferBindingInfo current_vertex_buffer_binding_info;
     bool vertex_buffer_used;  // Track for perf warning to make sure any bound vtx buffer used
     VkCommandBuffer primaryCommandBuffer;
-    // Track images and buffers that are updated by this CB at the point of a draw
-    std::unordered_set<VkImageView> updateImages;
-    std::unordered_set<VkBuffer> updateBuffers;
     // If primary, the secondary command buffers we will call.
     // If secondary, the primary command buffers we will be called by.
     std::unordered_set<CMD_BUFFER_STATE *> linkedCommandBuffers;
     // Validation functions run at primary CB queue submit time
     std::vector<std::function<bool()>> queue_submit_functions;
     // Validation functions run when secondary CB is executed in primary
-    std::vector<std::function<bool(CMD_BUFFER_STATE *, VkFramebuffer)>> cmd_execute_commands_functions;
+    std::vector<std::function<bool(const CMD_BUFFER_STATE *, VkFramebuffer)>> cmd_execute_commands_functions;
     std::unordered_set<VkDeviceMemory> memObjs;
     std::vector<std::function<bool(VkQueue)>> eventUpdates;
     std::vector<std::function<bool(VkQueue)>> queryUpdates;
@@ -1464,6 +1476,14 @@ struct CMD_BUFFER_STATE : public BASE_NODE {
     LoggingLabel debug_label;
 };
 
+static inline const QFOTransferBarrierSets<VkImageMemoryBarrier> &GetQFOBarrierSets(
+    const CMD_BUFFER_STATE *cb, const QFOTransferBarrier<VkImageMemoryBarrier>::Tag &type_tag) {
+    return cb->qfo_transfer_image_barriers;
+}
+static inline const QFOTransferBarrierSets<VkBufferMemoryBarrier> &GetQFOBarrierSets(
+    const CMD_BUFFER_STATE *cb, const QFOTransferBarrier<VkBufferMemoryBarrier>::Tag &type_tag) {
+    return cb->qfo_transfer_buffer_barriers;
+}
 static inline QFOTransferBarrierSets<VkImageMemoryBarrier> &GetQFOBarrierSets(
     CMD_BUFFER_STATE *cb, const QFOTransferBarrier<VkImageMemoryBarrier>::Tag &type_tag) {
     return cb->qfo_transfer_image_barriers;
@@ -1539,6 +1559,10 @@ struct DeviceFeatures {
     VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV fragment_shader_barycentric_features;
     VkPhysicalDeviceShaderImageFootprintFeaturesNV shader_image_footprint_features;
     VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT fragment_shader_interlock_features;
+    VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT demote_to_helper_invocation_features;
+    VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT texel_buffer_alignment_features;
+    VkPhysicalDeviceImagelessFramebufferFeaturesKHR imageless_framebuffer_features;
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR pipeline_exe_props_features;
 };
 
 enum RenderPassCreateVersion { RENDER_PASS_VERSION_1 = 0, RENDER_PASS_VERSION_2 = 1 };
diff --git a/layers/descriptor_sets.cpp b/layers/descriptor_sets.cpp
index 301cf014d..8dcdf8b44 100644
--- a/layers/descriptor_sets.cpp
+++ b/layers/descriptor_sets.cpp
@@ -318,7 +318,7 @@ bool cvdescriptorset::ValidateDescriptorSetLayoutCreateInfo(
     const uint32_t max_push_descriptors, const bool descriptor_indexing_ext,
     const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing_features,
     const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *inline_uniform_block_features,
-    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *inline_uniform_block_props) {
+    const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *inline_uniform_block_props, const DeviceExtensions *device_extensions) {
     bool skip = false;
     std::unordered_set<uint32_t> bindings;
     uint64_t total_descriptors = 0;
@@ -370,16 +370,24 @@ bool cvdescriptorset::ValidateDescriptorSetLayoutCreateInfo(
         }
 
         if (binding_info.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT) {
-            if ((binding_info.descriptorCount % 4) != 0) {
-                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                "VUID-VkDescriptorSetLayoutBinding-descriptorType-02209",
-                                "descriptorCount =(%" PRIu32 ") must be a multiple of 4", binding_info.descriptorCount);
-            }
-            if (binding_info.descriptorCount > inline_uniform_block_props->maxInlineUniformBlockSize) {
-                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                "VUID-VkDescriptorSetLayoutBinding-descriptorType-02210",
-                                "descriptorCount =(%" PRIu32 ") must be less than or equal to maxInlineUniformBlockSize",
-                                binding_info.descriptorCount);
+            if (!device_extensions->vk_ext_inline_uniform_block) {
+                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, 0,
+                                "UNASSIGNED-Extension not enabled",
+                                "Creating VkDescriptorSetLayout with descriptor type  VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT "
+                                "but extension %s is missing",
+                                VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME);
+            } else {
+                if ((binding_info.descriptorCount % 4) != 0) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkDescriptorSetLayoutBinding-descriptorType-02209",
+                                    "descriptorCount =(%" PRIu32 ") must be a multiple of 4", binding_info.descriptorCount);
+                }
+                if (binding_info.descriptorCount > inline_uniform_block_props->maxInlineUniformBlockSize) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkDescriptorSetLayoutBinding-descriptorType-02210",
+                                    "descriptorCount =(%" PRIu32 ") must be less than or equal to maxInlineUniformBlockSize",
+                                    binding_info.descriptorCount);
+                }
             }
         }
 
@@ -544,7 +552,8 @@ cvdescriptorset::DescriptorSet::DescriptorSet(const VkDescriptorSet set, const V
       pool_state_(nullptr),
       p_layout_(layout),
       state_data_(state_data),
-      variable_count_(variable_count) {
+      variable_count_(variable_count),
+      change_count_(0) {
     pool_state_ = state_data->GetDescriptorPoolState(pool);
     // Foreach binding, create default descriptors of given type
     descriptors_.reserve(p_layout_->GetTotalDescriptorCount());
@@ -630,7 +639,7 @@ static char const *StringDescriptorReqComponentType(descriptor_req req) {
     return "(none)";
 }
 
-static unsigned DescriptorRequirementsBitsFromFormat(VkFormat fmt) {
+unsigned DescriptorRequirementsBitsFromFormat(VkFormat fmt) {
     if (FormatIsSInt(fmt)) return DESCRIPTOR_REQ_COMPONENT_TYPE_SINT;
     if (FormatIsUInt(fmt)) return DESCRIPTOR_REQ_COMPONENT_TYPE_UINT;
     if (FormatIsDepthAndStencil(fmt)) return DESCRIPTOR_REQ_COMPONENT_TYPE_FLOAT | DESCRIPTOR_REQ_COMPONENT_TYPE_UINT;
@@ -644,8 +653,8 @@ static unsigned DescriptorRequirementsBitsFromFormat(VkFormat fmt) {
 //  that any update buffers are valid, and that any dynamic offsets are within the bounds of their buffers.
 // Return true if state is acceptable, or false and write an error message into error string
 bool CoreChecks::ValidateDrawState(const DescriptorSet *descriptor_set, const std::map<uint32_t, descriptor_req> &bindings,
-                                   const std::vector<uint32_t> &dynamic_offsets, CMD_BUFFER_STATE *cb_node, const char *caller,
-                                   std::string *error) {
+                                   const std::vector<uint32_t> &dynamic_offsets, const CMD_BUFFER_STATE *cb_node,
+                                   const char *caller, std::string *error) const {
     using DescriptorClass = cvdescriptorset::DescriptorClass;
     using BufferDescriptor = cvdescriptorset::BufferDescriptor;
     using ImageDescriptor = cvdescriptorset::ImageDescriptor;
@@ -662,6 +671,14 @@ bool CoreChecks::ValidateDrawState(const DescriptorSet *descriptor_set, const st
             *error = error_str.str();
             return false;
         }
+
+        if (binding_it.GetDescriptorBindingFlags() &
+            (VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT)) {
+            // Can't validate the descriptor because it may not have been updated,
+            // or the view could have been destroyed
+            continue;
+        }
+
         // Copy the range, the end range is subject to update based on variable length descriptor arrays.
         cvdescriptorset::IndexRange index_range = binding_it.GetGlobalIndexRange();
         auto array_idx = 0;  // Track array idx if we're dealing with array descriptors
@@ -675,11 +692,8 @@ bool CoreChecks::ValidateDrawState(const DescriptorSet *descriptor_set, const st
             uint32_t index = i - index_range.start;
             const auto *descriptor = descriptor_set->GetDescriptorFromGlobalIndex(i);
 
-            if ((binding_it.GetDescriptorBindingFlags() &
-                 (VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT)) ||
-                descriptor->GetClass() == DescriptorClass::InlineUniform) {
-                // Can't validate the descriptor because it may not have been updated,
-                // or the view could have been destroyed
+            if (descriptor->GetClass() == DescriptorClass::InlineUniform) {
+                // Can't validate the descriptor because it may not have been updated.
                 continue;
             } else if (!descriptor->updated) {
                 std::stringstream error_str;
@@ -760,55 +774,59 @@ bool CoreChecks::ValidateDrawState(const DescriptorSet *descriptor_set, const st
                         *error = error_str.str();
                         return false;
                     }
-                    auto image_view_ci = image_view_state->create_info;
+                    const auto &image_view_ci = image_view_state->create_info;
 
-                    if ((reqs & DESCRIPTOR_REQ_ALL_VIEW_TYPE_BITS) && (~reqs & (1 << image_view_ci.viewType))) {
-                        // bad view type
-                        std::stringstream error_str;
-                        error_str << "Descriptor in binding #" << binding << " index " << index
-                                  << " requires an image view of type " << StringDescriptorReqViewType(reqs) << " but got "
-                                  << string_VkImageViewType(image_view_ci.viewType) << ".";
-                        *error = error_str.str();
-                        return false;
-                    }
+                    if (reqs & DESCRIPTOR_REQ_ALL_VIEW_TYPE_BITS) {
+                        if (~reqs & (1 << image_view_ci.viewType)) {
+                            // bad view type
+                            std::stringstream error_str;
+                            error_str << "Descriptor in binding #" << binding << " index " << index
+                                      << " requires an image view of type " << StringDescriptorReqViewType(reqs) << " but got "
+                                      << string_VkImageViewType(image_view_ci.viewType) << ".";
+                            *error = error_str.str();
+                            return false;
+                        }
 
-                    auto format_bits = DescriptorRequirementsBitsFromFormat(image_view_ci.format);
-                    if (!(reqs & format_bits)) {
-                        // bad component type
-                        std::stringstream error_str;
-                        error_str << "Descriptor in binding #" << binding << " index " << index << " requires "
-                                  << StringDescriptorReqComponentType(reqs) << " component type, but bound descriptor format is "
-                                  << string_VkFormat(image_view_ci.format) << ".";
-                        *error = error_str.str();
-                        return false;
+                        if (!(reqs & image_view_state->descriptor_format_bits)) {
+                            // bad component type
+                            std::stringstream error_str;
+                            error_str << "Descriptor in binding #" << binding << " index " << index << " requires "
+                                      << StringDescriptorReqComponentType(reqs)
+                                      << " component type, but bound descriptor format is " << string_VkFormat(image_view_ci.format)
+                                      << ".";
+                            *error = error_str.str();
+                            return false;
+                        }
                     }
 
-                    auto image_node = GetImageState(image_view_ci.image);
-                    assert(image_node);
-                    // Verify Image Layout
-                    // No "invalid layout" VUID required for this call, since the optimal_layout parameter is UNDEFINED.
-                    bool hit_error = false;
-                    VerifyImageLayout(cb_node, image_node, image_view_state->normalized_subresource_range,
-                                      image_view_ci.subresourceRange.aspectMask, image_layout, VK_IMAGE_LAYOUT_UNDEFINED, caller,
-                                      kVUIDUndefined, "VUID-VkDescriptorImageInfo-imageLayout-00344", &hit_error);
-                    if (hit_error) {
-                        *error =
-                            "Image layout specified at vkUpdateDescriptorSet* or vkCmdPushDescriptorSet* time "
-                            "doesn't match actual image layout at time descriptor is used. See previous error callback for "
-                            "specific details.";
-                        return false;
+                    if (!disabled.image_layout_validation) {
+                        auto image_node = GetImageState(image_view_ci.image);
+                        assert(image_node);
+                        // Verify Image Layout
+                        // No "invalid layout" VUID required for this call, since the optimal_layout parameter is UNDEFINED.
+                        bool hit_error = false;
+                        VerifyImageLayout(cb_node, image_node, image_view_state->normalized_subresource_range,
+                                          image_view_ci.subresourceRange.aspectMask, image_layout, VK_IMAGE_LAYOUT_UNDEFINED,
+                                          caller, kVUIDUndefined, "VUID-VkDescriptorImageInfo-imageLayout-00344", &hit_error);
+                        if (hit_error) {
+                            *error =
+                                "Image layout specified at vkUpdateDescriptorSet* or vkCmdPushDescriptorSet* time "
+                                "doesn't match actual image layout at time descriptor is used. See previous error callback for "
+                                "specific details.";
+                            return false;
+                        }
                     }
 
                     // Verify Sample counts
-                    if ((reqs & DESCRIPTOR_REQ_SINGLE_SAMPLE) && image_node->createInfo.samples != VK_SAMPLE_COUNT_1_BIT) {
+                    if ((reqs & DESCRIPTOR_REQ_SINGLE_SAMPLE) && image_view_state->samples != VK_SAMPLE_COUNT_1_BIT) {
                         std::stringstream error_str;
                         error_str << "Descriptor in binding #" << binding << " index " << index
                                   << " requires bound image to have VK_SAMPLE_COUNT_1_BIT but got "
-                                  << string_VkSampleCountFlagBits(image_node->createInfo.samples) << ".";
+                                  << string_VkSampleCountFlagBits(image_view_state->samples) << ".";
                         *error = error_str.str();
                         return false;
                     }
-                    if ((reqs & DESCRIPTOR_REQ_MULTI_SAMPLE) && image_node->createInfo.samples == VK_SAMPLE_COUNT_1_BIT) {
+                    if ((reqs & DESCRIPTOR_REQ_MULTI_SAMPLE) && image_view_state->samples == VK_SAMPLE_COUNT_1_BIT) {
                         std::stringstream error_str;
                         error_str << "Descriptor in binding #" << binding << " index " << index
                                   << " requires bound image to have multiple samples, but got VK_SAMPLE_COUNT_1_BIT.";
@@ -863,7 +881,7 @@ bool CoreChecks::ValidateDrawState(const DescriptorSet *descriptor_set, const st
                         *error = error_str.str();
                         return false;
                     } else {
-                        SAMPLER_STATE *sampler_state = GetSamplerState(sampler);
+                        const SAMPLER_STATE *sampler_state = GetSamplerState(sampler);
                         if (sampler_state->samplerConversion && !descriptor->IsImmutableSampler()) {
                             std::stringstream error_str;
                             error_str << "sampler (" << sampler << ") in the descriptor set (" << descriptor_set->GetSet()
@@ -879,49 +897,6 @@ bool CoreChecks::ValidateDrawState(const DescriptorSet *descriptor_set, const st
     return true;
 }
 
-// For given bindings, place any update buffers or images into the passed-in unordered_sets
-uint32_t cvdescriptorset::DescriptorSet::GetStorageUpdates(const std::map<uint32_t, descriptor_req> &bindings,
-                                                           std::unordered_set<VkBuffer> *buffer_set,
-                                                           std::unordered_set<VkImageView> *image_set) const {
-    auto num_updates = 0;
-    for (auto binding_pair : bindings) {
-        auto binding = binding_pair.first;
-        // If a binding doesn't exist, skip it
-        if (!p_layout_->HasBinding(binding)) {
-            continue;
-        }
-        uint32_t start_idx = p_layout_->GetGlobalIndexRangeFromBinding(binding).start;
-        if (descriptors_[start_idx]->IsStorage()) {
-            if (Image == descriptors_[start_idx]->descriptor_class) {
-                for (uint32_t i = 0; i < p_layout_->GetDescriptorCountFromBinding(binding); ++i) {
-                    if (descriptors_[start_idx + i]->updated) {
-                        image_set->insert(static_cast<ImageDescriptor *>(descriptors_[start_idx + i].get())->GetImageView());
-                        num_updates++;
-                    }
-                }
-            } else if (TexelBuffer == descriptors_[start_idx]->descriptor_class) {
-                for (uint32_t i = 0; i < p_layout_->GetDescriptorCountFromBinding(binding); ++i) {
-                    if (descriptors_[start_idx + i]->updated) {
-                        auto bufferview = static_cast<TexelDescriptor *>(descriptors_[start_idx + i].get())->GetBufferView();
-                        auto bv_state = state_data_->GetBufferViewState(bufferview);
-                        if (bv_state) {
-                            buffer_set->insert(bv_state->create_info.buffer);
-                            num_updates++;
-                        }
-                    }
-                }
-            } else if (GeneralBuffer == descriptors_[start_idx]->descriptor_class) {
-                for (uint32_t i = 0; i < p_layout_->GetDescriptorCountFromBinding(binding); ++i) {
-                    if (descriptors_[start_idx + i]->updated) {
-                        buffer_set->insert(static_cast<BufferDescriptor *>(descriptors_[start_idx + i].get())->GetBuffer());
-                        num_updates++;
-                    }
-                }
-            }
-        }
-    }
-    return num_updates;
-}
 // Set is being deleted or updates so invalidate all bound cmd buffers
 void cvdescriptorset::DescriptorSet::InvalidateBoundCmdBuffers() {
     state_data_->InvalidateCommandBuffers(cb_bindings, VulkanTypedHandle(set_, kVulkanObjectTypeDescriptorSet));
@@ -954,7 +929,10 @@ void cvdescriptorset::DescriptorSet::PerformWriteUpdate(const VkWriteDescriptorS
         offset = 0;
         binding_being_updated++;
     }
-    if (update->descriptorCount) some_update_ = true;
+    if (update->descriptorCount) {
+        some_update_ = true;
+        change_count_++;
+    }
 
     if (!(p_layout_->GetDescriptorBindingFlagsFromBinding(update->dstBinding) &
           (VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT))) {
@@ -1172,6 +1150,7 @@ void cvdescriptorset::DescriptorSet::PerformCopyUpdate(const VkCopyDescriptorSet
         if (src->updated) {
             dst->CopyUpdate(src);
             some_update_ = true;
+            change_count_++;
         } else {
             dst->updated = false;
         }
@@ -1190,14 +1169,27 @@ void cvdescriptorset::DescriptorSet::PerformCopyUpdate(const VkCopyDescriptorSet
 // TODO: Modify the UpdateDrawState virtural functions to *only* set initial layout and not change layouts
 // Prereq: This should be called for a set that has been confirmed to be active for the given cb_node, meaning it's going
 //   to be used in a draw by the given cb_node
-void cvdescriptorset::DescriptorSet::UpdateDrawState(CoreChecks *device_data, CMD_BUFFER_STATE *cb_node,
+void cvdescriptorset::DescriptorSet::UpdateDrawState(ValidationStateTracker *device_data, CMD_BUFFER_STATE *cb_node,
                                                      const std::map<uint32_t, descriptor_req> &binding_req_map) {
-    // bind cb to this descriptor set
-    cb_bindings.insert(cb_node);
-    // Add bindings for descriptor set, the set's pool, and individual objects in the set
-    cb_node->object_bindings.emplace(set_, kVulkanObjectTypeDescriptorSet);
-    pool_state_->cb_bindings.insert(cb_node);
-    cb_node->object_bindings.emplace(pool_state_->pool, kVulkanObjectTypeDescriptorPool);
+    if (!device_data->disabled.command_buffer_state) {
+        // bind cb to this descriptor set
+        // Add bindings for descriptor set, the set's pool, and individual objects in the set
+        auto inserted = cb_node->object_bindings.emplace(set_, kVulkanObjectTypeDescriptorSet);
+        if (inserted.second) {
+            cb_bindings.insert(cb_node);
+            auto inserted2 = cb_node->object_bindings.emplace(pool_state_->pool, kVulkanObjectTypeDescriptorPool);
+            if (inserted2.second) {
+                pool_state_->cb_bindings.insert(cb_node);
+            }
+        }
+    }
+
+    // Descriptor UpdateDrawState functions do two things - associate resources to the command buffer,
+    // and call image layout validation callbacks. If both are disabled, skip the entire loop.
+    if (device_data->disabled.command_buffer_state && device_data->disabled.image_layout_validation) {
+        return;
+    }
+
     // For the active slots, use set# to look up descriptorSet from boundDescriptorSets, and bind all of that descriptor set's
     // resources
     for (auto binding_req_pair : binding_req_map) {
@@ -1214,47 +1206,34 @@ void cvdescriptorset::DescriptorSet::UpdateDrawState(CoreChecks *device_data, CM
     }
 }
 
-void cvdescriptorset::DescriptorSet::FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair,
-                                                                 const BindingReqMap &in_req, BindingReqMap *out_req,
-                                                                 TrackedBindings *bindings) {
-    assert(out_req);
-    assert(bindings);
-    const auto binding = binding_req_pair.first;
-    // Use insert and look at the boolean ("was inserted") in the returned pair to see if this is a new set member.
-    // Saves one hash lookup vs. find ... compare w/ end ... insert.
-    const auto it_bool_pair = bindings->insert(binding);
-    if (it_bool_pair.second) {
-        out_req->emplace(binding_req_pair);
+void cvdescriptorset::DescriptorSet::FilterOneBindingReq(const BindingReqMap::value_type &binding_req_pair, BindingReqMap *out_req,
+                                                         const TrackedBindings &bindings, uint32_t limit) {
+    if (bindings.size() < limit) {
+        const auto it = bindings.find(binding_req_pair.first);
+        if (it == bindings.cend()) out_req->emplace(binding_req_pair);
     }
 }
 
-void cvdescriptorset::DescriptorSet::FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair,
-                                                                 const BindingReqMap &in_req, BindingReqMap *out_req,
-                                                                 TrackedBindings *bindings, uint32_t limit) {
-    if (bindings->size() < limit) FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, bindings);
-}
-
-void cvdescriptorset::DescriptorSet::FilterAndTrackBindingReqs(CMD_BUFFER_STATE *cb_state, const BindingReqMap &in_req,
-                                                               BindingReqMap *out_req) {
-    TrackedBindings &bound = cached_validation_[cb_state].command_binding_and_usage;
-    if (bound.size() == GetBindingCount()) {
-        return;  // All bindings are bound, out req is empty
-    }
-    for (const auto &binding_req_pair : in_req) {
-        const auto binding = binding_req_pair.first;
-        // If a binding doesn't exist, or has already been bound, skip it
-        if (p_layout_->HasBinding(binding)) {
-            FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, &bound);
+void cvdescriptorset::DescriptorSet::FilterBindingReqs(const CMD_BUFFER_STATE &cb_state, const PIPELINE_STATE &pipeline,
+                                                       const BindingReqMap &in_req, BindingReqMap *out_req) const {
+    // For const cleanliness we have to find in the maps...
+    const auto validated_it = cached_validation_.find(&cb_state);
+    if (validated_it == cached_validation_.cend()) {
+        // We have nothing validated, copy in to out
+        for (const auto &binding_req_pair : in_req) {
+            out_req->emplace(binding_req_pair);
         }
+        return;
     }
-}
+    const auto &validated = validated_it->second;
 
-void cvdescriptorset::DescriptorSet::FilterAndTrackBindingReqs(CMD_BUFFER_STATE *cb_state, PIPELINE_STATE *pipeline,
-                                                               const BindingReqMap &in_req, BindingReqMap *out_req) {
-    auto &validated = cached_validation_[cb_state];
-    auto &image_sample_val = validated.image_samplers[pipeline];
-    auto *const dynamic_buffers = &validated.dynamic_buffers;
-    auto *const non_dynamic_buffers = &validated.non_dynamic_buffers;
+    const auto image_sample_version_it = validated.image_samplers.find(&pipeline);
+    const VersionedBindings *image_sample_version = nullptr;
+    if (image_sample_version_it != validated.image_samplers.cend()) {
+        image_sample_version = &(image_sample_version_it->second);
+    }
+    const auto &dynamic_buffers = validated.dynamic_buffers;
+    const auto &non_dynamic_buffers = validated.non_dynamic_buffers;
     const auto &stats = p_layout_->GetBindingTypeStats();
     for (const auto &binding_req_pair : in_req) {
         auto binding = binding_req_pair.first;
@@ -1266,22 +1245,55 @@ void cvdescriptorset::DescriptorSet::FilterAndTrackBindingReqs(CMD_BUFFER_STATE
         // If image_layout have changed , the image descriptors need to be validated against them.
         if ((layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) ||
             (layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
-            FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, dynamic_buffers, stats.dynamic_buffer_count);
+            FilterOneBindingReq(binding_req_pair, out_req, dynamic_buffers, stats.dynamic_buffer_count);
         } else if ((layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
                    (layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)) {
-            FilterAndTrackOneBindingReq(binding_req_pair, in_req, out_req, non_dynamic_buffers, stats.non_dynamic_buffer_count);
+            FilterOneBindingReq(binding_req_pair, out_req, non_dynamic_buffers, stats.non_dynamic_buffer_count);
         } else {
             // This is rather crude, as the changed layouts may not impact the bound descriptors,
             // but the simple "versioning" is a simple "dirt" test.
-            auto &version = image_sample_val[binding];  // Take advantage of default construtor zero initialzing new entries
-            if (version != cb_state->image_layout_change_count) {
-                version = cb_state->image_layout_change_count;
+            bool stale = true;
+            if (image_sample_version) {
+                const auto version_it = image_sample_version->find(binding);
+                if (version_it != image_sample_version->cend() && (version_it->second == cb_state.image_layout_change_count)) {
+                    stale = false;
+                }
+            }
+            if (stale) {
                 out_req->emplace(binding_req_pair);
             }
         }
     }
 }
 
+void cvdescriptorset::DescriptorSet::UpdateValidationCache(const CMD_BUFFER_STATE &cb_state, const PIPELINE_STATE &pipeline,
+                                                           const BindingReqMap &updated_bindings) {
+    // For const cleanliness we have to find in the maps...
+    auto &validated = cached_validation_[&cb_state];
+
+    auto &image_sample_version = validated.image_samplers[&pipeline];
+    auto &dynamic_buffers = validated.dynamic_buffers;
+    auto &non_dynamic_buffers = validated.non_dynamic_buffers;
+    for (const auto &binding_req_pair : updated_bindings) {
+        auto binding = binding_req_pair.first;
+        VkDescriptorSetLayoutBinding const *layout_binding = p_layout_->GetDescriptorSetLayoutBindingPtrFromBinding(binding);
+        if (!layout_binding) {
+            continue;
+        }
+        // Caching criteria differs per type.
+        if ((layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) ||
+            (layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
+            dynamic_buffers.emplace(binding);
+        } else if ((layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) ||
+                   (layout_binding->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)) {
+            non_dynamic_buffers.emplace(binding);
+        } else {
+            // Save the layout change version...
+            image_sample_version[binding] = cb_state.image_layout_change_count;
+        }
+    }
+}
+
 cvdescriptorset::SamplerDescriptor::SamplerDescriptor(const VkSampler *immut) : sampler_(VK_NULL_HANDLE), immutable_(false) {
     updated = false;
     descriptor_class = PlainSampler;
@@ -1529,7 +1541,7 @@ void cvdescriptorset::SamplerDescriptor::CopyUpdate(const Descriptor *src) {
     updated = true;
 }
 
-void cvdescriptorset::SamplerDescriptor::UpdateDrawState(CoreChecks *dev_data, CMD_BUFFER_STATE *cb_node) {
+void cvdescriptorset::SamplerDescriptor::UpdateDrawState(ValidationStateTracker *dev_data, CMD_BUFFER_STATE *cb_node) {
     if (!immutable_) {
         auto sampler_state = dev_data->GetSamplerState(sampler_);
         if (sampler_state) dev_data->AddCommandBufferBindingSampler(cb_node, sampler_state);
@@ -1568,7 +1580,7 @@ void cvdescriptorset::ImageSamplerDescriptor::CopyUpdate(const Descriptor *src)
     image_layout_ = image_layout;
 }
 
-void cvdescriptorset::ImageSamplerDescriptor::UpdateDrawState(CoreChecks *dev_data, CMD_BUFFER_STATE *cb_node) {
+void cvdescriptorset::ImageSamplerDescriptor::UpdateDrawState(ValidationStateTracker *dev_data, CMD_BUFFER_STATE *cb_node) {
     // First add binding for any non-immutable sampler
     if (!immutable_) {
         auto sampler_state = dev_data->GetSamplerState(sampler_);
@@ -1578,7 +1590,7 @@ void cvdescriptorset::ImageSamplerDescriptor::UpdateDrawState(CoreChecks *dev_da
     auto iv_state = dev_data->GetImageViewState(image_view_);
     if (iv_state) {
         dev_data->AddCommandBufferBindingImageView(cb_node, iv_state);
-        dev_data->SetImageViewInitialLayout(cb_node, *iv_state, image_layout_);
+        dev_data->CallSetImageViewInitialLayoutCallback(cb_node, *iv_state, image_layout_);
     }
 }
 
@@ -1604,12 +1616,12 @@ void cvdescriptorset::ImageDescriptor::CopyUpdate(const Descriptor *src) {
     image_layout_ = image_layout;
 }
 
-void cvdescriptorset::ImageDescriptor::UpdateDrawState(CoreChecks *dev_data, CMD_BUFFER_STATE *cb_node) {
+void cvdescriptorset::ImageDescriptor::UpdateDrawState(ValidationStateTracker *dev_data, CMD_BUFFER_STATE *cb_node) {
     // Add binding for image
     auto iv_state = dev_data->GetImageViewState(image_view_);
     if (iv_state) {
         dev_data->AddCommandBufferBindingImageView(cb_node, iv_state);
-        dev_data->SetImageViewInitialLayout(cb_node, *iv_state, image_layout_);
+        dev_data->CallSetImageViewInitialLayoutCallback(cb_node, *iv_state, image_layout_);
     }
 }
 
@@ -1642,7 +1654,7 @@ void cvdescriptorset::BufferDescriptor::CopyUpdate(const Descriptor *src) {
     range_ = buff_desc->range_;
 }
 
-void cvdescriptorset::BufferDescriptor::UpdateDrawState(CoreChecks *dev_data, CMD_BUFFER_STATE *cb_node) {
+void cvdescriptorset::BufferDescriptor::UpdateDrawState(ValidationStateTracker *dev_data, CMD_BUFFER_STATE *cb_node) {
     auto buffer_node = dev_data->GetBufferState(buffer_);
     if (buffer_node) dev_data->AddCommandBufferBindingBuffer(cb_node, buffer_node);
 }
@@ -1663,7 +1675,7 @@ void cvdescriptorset::TexelDescriptor::CopyUpdate(const Descriptor *src) {
     buffer_view_ = static_cast<const TexelDescriptor *>(src)->buffer_view_;
 }
 
-void cvdescriptorset::TexelDescriptor::UpdateDrawState(CoreChecks *dev_data, CMD_BUFFER_STATE *cb_node) {
+void cvdescriptorset::TexelDescriptor::UpdateDrawState(ValidationStateTracker *dev_data, CMD_BUFFER_STATE *cb_node) {
     auto bv_state = dev_data->GetBufferViewState(buffer_view_);
     if (bv_state) {
         dev_data->AddCommandBufferBindingBufferView(cb_node, bv_state);
@@ -2259,21 +2271,14 @@ void ValidationStateTracker::PerformAllocateDescriptorSets(const VkDescriptorSet
     }
 }
 
-cvdescriptorset::PrefilterBindRequestMap::PrefilterBindRequestMap(cvdescriptorset::DescriptorSet &ds, const BindingReqMap &in_map,
-                                                                  CMD_BUFFER_STATE *cb_state)
-    : filtered_map_(), orig_map_(in_map) {
-    if (ds.GetTotalDescriptorCount() > kManyDescriptors_) {
-        filtered_map_.reset(new std::map<uint32_t, descriptor_req>());
-        ds.FilterAndTrackBindingReqs(cb_state, orig_map_, filtered_map_.get());
-    }
-}
-cvdescriptorset::PrefilterBindRequestMap::PrefilterBindRequestMap(cvdescriptorset::DescriptorSet &ds, const BindingReqMap &in_map,
-                                                                  CMD_BUFFER_STATE *cb_state, PIPELINE_STATE *pipeline)
-    : filtered_map_(), orig_map_(in_map) {
-    if (ds.GetTotalDescriptorCount() > kManyDescriptors_) {
+const BindingReqMap &cvdescriptorset::PrefilterBindRequestMap::FilteredMap(const CMD_BUFFER_STATE &cb_state,
+                                                                           const PIPELINE_STATE &pipeline) {
+    if (IsManyDescriptors()) {
         filtered_map_.reset(new std::map<uint32_t, descriptor_req>());
-        ds.FilterAndTrackBindingReqs(cb_state, pipeline, orig_map_, filtered_map_.get());
+        descriptor_set_.FilterBindingReqs(cb_state, pipeline, orig_map_, filtered_map_.get());
+        return *filtered_map_;
     }
+    return orig_map_;
 }
 
 // Starting at offset descriptor of given binding, parse over update_count
diff --git a/layers/descriptor_sets.h b/layers/descriptor_sets.h
index ed9bd4014..598f4395e 100644
--- a/layers/descriptor_sets.h
+++ b/layers/descriptor_sets.h
@@ -48,7 +48,6 @@ struct IndexRange {
     uint32_t start;
     uint32_t end;
 };
-typedef std::map<uint32_t, descriptor_req> BindingReqMap;
 
 /*
  * DescriptorSetLayoutDef/DescriptorSetLayout classes
@@ -359,7 +358,7 @@ class Descriptor {
     virtual void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) = 0;
     virtual void CopyUpdate(const Descriptor *) = 0;
     // Create binding between resources of this descriptor and given cb_node
-    virtual void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) = 0;
+    virtual void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) = 0;
     virtual DescriptorClass GetClass() const { return descriptor_class; };
     // Special fast-path check for SamplerDescriptors that are immutable
     virtual bool IsImmutableSampler() const { return false; };
@@ -380,14 +379,15 @@ bool ValidateDescriptorSetLayoutCreateInfo(const debug_report_data *report_data,
                                            const bool descriptor_indexing_ext,
                                            const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing_features,
                                            const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *inline_uniform_block_features,
-                                           const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *inline_uniform_block_props);
+                                           const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *inline_uniform_block_props,
+                                           const DeviceExtensions *device_extensions);
 
 class SamplerDescriptor : public Descriptor {
    public:
     SamplerDescriptor(const VkSampler *);
     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
     void CopyUpdate(const Descriptor *) override;
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) override;
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) override;
     virtual bool IsImmutableSampler() const override { return immutable_; };
     VkSampler GetSampler() const { return sampler_; }
 
@@ -401,7 +401,7 @@ class ImageSamplerDescriptor : public Descriptor {
     ImageSamplerDescriptor(const VkSampler *);
     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
     void CopyUpdate(const Descriptor *) override;
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) override;
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) override;
     virtual bool IsImmutableSampler() const override { return immutable_; };
     VkSampler GetSampler() const { return sampler_; }
     VkImageView GetImageView() const { return image_view_; }
@@ -419,7 +419,7 @@ class ImageDescriptor : public Descriptor {
     ImageDescriptor(const VkDescriptorType);
     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
     void CopyUpdate(const Descriptor *) override;
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) override;
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) override;
     virtual bool IsStorage() const override { return storage_; }
     VkImageView GetImageView() const { return image_view_; }
     VkImageLayout GetImageLayout() const { return image_layout_; }
@@ -435,7 +435,7 @@ class TexelDescriptor : public Descriptor {
     TexelDescriptor(const VkDescriptorType);
     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
     void CopyUpdate(const Descriptor *) override;
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) override;
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) override;
     virtual bool IsStorage() const override { return storage_; }
     VkBufferView GetBufferView() const { return buffer_view_; }
 
@@ -449,7 +449,7 @@ class BufferDescriptor : public Descriptor {
     BufferDescriptor(const VkDescriptorType);
     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override;
     void CopyUpdate(const Descriptor *) override;
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) override;
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) override;
     virtual bool IsDynamic() const override { return dynamic_; }
     virtual bool IsStorage() const override { return storage_; }
     VkBuffer GetBuffer() const { return buffer_; }
@@ -472,7 +472,7 @@ class InlineUniformDescriptor : public Descriptor {
     }
     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override { updated = true; }
     void CopyUpdate(const Descriptor *) override { updated = true; }
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) override {}
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) override {}
 };
 
 class AccelerationStructureDescriptor : public Descriptor {
@@ -483,7 +483,7 @@ class AccelerationStructureDescriptor : public Descriptor {
     }
     void WriteUpdate(const VkWriteDescriptorSet *, const uint32_t) override { updated = true; }
     void CopyUpdate(const Descriptor *) override { updated = true; }
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *) override {}
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *) override {}
 };
 
 // Structs to contain common elements that need to be shared between Validate* and Perform* calls below
@@ -559,10 +559,6 @@ class DescriptorSet : public BASE_NODE {
     }
     // Return true if given binding is present in this set
     bool HasBinding(const uint32_t binding) const { return p_layout_->HasBinding(binding); };
-    // For given set of bindings, add any buffers and images that will be updated to their respective unordered_sets & return number
-    // of objects inserted
-    uint32_t GetStorageUpdates(const std::map<uint32_t, descriptor_req> &, std::unordered_set<VkBuffer> *,
-                               std::unordered_set<VkImageView> *) const;
 
     std::string StringifySetAndLayout() const;
 
@@ -580,17 +576,17 @@ class DescriptorSet : public BASE_NODE {
     std::unordered_set<CMD_BUFFER_STATE *> GetBoundCmdBuffers() const { return cb_bindings; }
     // Bind given cmd_buffer to this descriptor set and
     // update CB image layout map with image/imagesampler descriptor image layouts
-    void UpdateDrawState(CoreChecks *, CMD_BUFFER_STATE *, const std::map<uint32_t, descriptor_req> &);
+    void UpdateDrawState(ValidationStateTracker *, CMD_BUFFER_STATE *, const std::map<uint32_t, descriptor_req> &);
 
     // Track work that has been bound or validated to avoid duplicate work, important when large descriptor arrays
     // are present
     typedef std::unordered_set<uint32_t> TrackedBindings;
-    static void FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, const BindingReqMap &in_req,
-                                            BindingReqMap *out_req, TrackedBindings *set);
-    static void FilterAndTrackOneBindingReq(const BindingReqMap::value_type &binding_req_pair, const BindingReqMap &in_req,
-                                            BindingReqMap *out_req, TrackedBindings *set, uint32_t limit);
-    void FilterAndTrackBindingReqs(CMD_BUFFER_STATE *, const BindingReqMap &in_req, BindingReqMap *out_req);
-    void FilterAndTrackBindingReqs(CMD_BUFFER_STATE *, PIPELINE_STATE *, const BindingReqMap &in_req, BindingReqMap *out_req);
+    static void FilterOneBindingReq(const BindingReqMap::value_type &binding_req_pair, BindingReqMap *out_req,
+                                    const TrackedBindings &set, uint32_t limit);
+    void FilterBindingReqs(const CMD_BUFFER_STATE &, const PIPELINE_STATE &, const BindingReqMap &in_req,
+                           BindingReqMap *out_req) const;
+    void UpdateValidationCache(const CMD_BUFFER_STATE &cb_state, const PIPELINE_STATE &pipeline,
+                               const BindingReqMap &updated_bindings);
     void ClearCachedDynamicDescriptorValidation(CMD_BUFFER_STATE *cb_state) {
         cached_validation_[cb_state].dynamic_buffers.clear();
     }
@@ -623,6 +619,7 @@ class DescriptorSet : public BASE_NODE {
     uint32_t GetVariableDescriptorCount() const { return variable_count_; }
     DESCRIPTOR_POOL_STATE *GetPoolState() const { return pool_state_; }
     const Descriptor *GetDescriptorFromGlobalIndex(const uint32_t index) const { return descriptors_[index].get(); }
+    uint64_t GetChangeCount() const { return change_count_; }
 
    private:
     // Private helper to set all bound cmd buffers to INVALID state
@@ -634,6 +631,7 @@ class DescriptorSet : public BASE_NODE {
     std::vector<std::unique_ptr<Descriptor>> descriptors_;
     StateTracker *state_data_;
     uint32_t variable_count_;
+    uint64_t change_count_;
 
     // Cached binding and validation support:
     //
@@ -643,12 +641,12 @@ class DescriptorSet : public BASE_NODE {
     // Track the validation caching of bindings vs. the command buffer and draw state
     typedef std::unordered_map<uint32_t, CMD_BUFFER_STATE::ImageLayoutUpdateCount> VersionedBindings;
     struct CachedValidation {
-        TrackedBindings command_binding_and_usage;                               // Persistent for the life of the recording
-        TrackedBindings non_dynamic_buffers;                                     // Persistent for the life of the recording
-        TrackedBindings dynamic_buffers;                                         // Dirtied (flushed) each BindDescriptorSet
-        std::unordered_map<PIPELINE_STATE *, VersionedBindings> image_samplers;  // Tested vs. changes to CB's ImageLayout
+        TrackedBindings command_binding_and_usage;                                     // Persistent for the life of the recording
+        TrackedBindings non_dynamic_buffers;                                           // Persistent for the life of the recording
+        TrackedBindings dynamic_buffers;                                               // Dirtied (flushed) each BindDescriptorSet
+        std::unordered_map<const PIPELINE_STATE *, VersionedBindings> image_samplers;  // Tested vs. changes to CB's ImageLayout
     };
-    typedef std::unordered_map<CMD_BUFFER_STATE *, CachedValidation> CachedValidationMap;
+    typedef std::unordered_map<const CMD_BUFFER_STATE *, CachedValidation> CachedValidationMap;
     // Image and ImageView bindings are validated per pipeline and not invalidate by repeated binding
     CachedValidationMap cached_validation_;
 };
@@ -658,10 +656,12 @@ class PrefilterBindRequestMap {
     static const uint32_t kManyDescriptors_ = 64;  // TODO base this number on measured data
     std::unique_ptr<BindingReqMap> filtered_map_;
     const BindingReqMap &orig_map_;
+    const DescriptorSet &descriptor_set_;
 
-    PrefilterBindRequestMap(DescriptorSet &ds, const BindingReqMap &in_map, CMD_BUFFER_STATE *cb_state);
-    PrefilterBindRequestMap(DescriptorSet &ds, const BindingReqMap &in_map, CMD_BUFFER_STATE *cb_state, PIPELINE_STATE *);
-    const BindingReqMap &Map() const { return (filtered_map_) ? *filtered_map_ : orig_map_; }
+    PrefilterBindRequestMap(const DescriptorSet &ds, const BindingReqMap &in_map)
+        : filtered_map_(), orig_map_(in_map), descriptor_set_(ds) {}
+    const BindingReqMap &FilteredMap(const CMD_BUFFER_STATE &cb_state, const PIPELINE_STATE &);
+    bool IsManyDescriptors() const { return descriptor_set_.GetTotalDescriptorCount() > kManyDescriptors_; }
 };
 }  // namespace cvdescriptorset
 #endif  // CORE_VALIDATION_DESCRIPTOR_SETS_H_
diff --git a/layers/drawdispatch.cpp b/layers/drawdispatch.cpp
index f3f2b4210..8779d956e 100644
--- a/layers/drawdispatch.cpp
+++ b/layers/drawdispatch.cpp
@@ -41,15 +41,17 @@
 #include "chassis.h"
 #include "core_validation.h"
 
-static inline void UpdateResourceTrackingOnDraw(CMD_BUFFER_STATE *pCB) { pCB->draw_data.push_back(pCB->current_draw_data); }
+static inline void UpdateResourceTrackingOnDraw(CMD_BUFFER_STATE *pCB) {
+    pCB->cb_vertex_buffer_binding_info.push_back(pCB->current_vertex_buffer_binding_info);
+}
 
 // Generic function to handle validation for all CmdDraw* type functions
 bool CoreChecks::ValidateCmdDrawType(VkCommandBuffer cmd_buffer, bool indexed, VkPipelineBindPoint bind_point, CMD_TYPE cmd_type,
                                      const char *caller, VkQueueFlags queue_flags, const char *queue_flag_code,
                                      const char *renderpass_msg_code, const char *pipebound_msg_code,
-                                     const char *dynamic_state_msg_code) {
+                                     const char *dynamic_state_msg_code) const {
     bool skip = false;
-    CMD_BUFFER_STATE *cb_state = GetCBState(cmd_buffer);
+    const CMD_BUFFER_STATE *cb_state = GetCBState(cmd_buffer);
     if (cb_state) {
         skip |= ValidateCmdQueueFlags(cb_state, caller, queue_flags, queue_flag_code);
         skip |= ValidateCmd(cb_state, cmd_type, caller);
@@ -62,12 +64,13 @@ bool CoreChecks::ValidateCmdDrawType(VkCommandBuffer cmd_buffer, bool indexed, V
 }
 
 // Generic function to handle state update for all CmdDraw* and CmdDispatch* type functions
-void CoreChecks::UpdateStateCmdDrawDispatchType(CMD_BUFFER_STATE *cb_state, VkPipelineBindPoint bind_point) {
+void ValidationStateTracker::UpdateStateCmdDrawDispatchType(CMD_BUFFER_STATE *cb_state, VkPipelineBindPoint bind_point) {
     UpdateDrawState(cb_state, bind_point);
+    cb_state->hasDispatchCmd = true;
 }
 
 // Generic function to handle state update for all CmdDraw* type functions
-void CoreChecks::UpdateStateCmdDrawType(CMD_BUFFER_STATE *cb_state, VkPipelineBindPoint bind_point) {
+void ValidationStateTracker::UpdateStateCmdDrawType(CMD_BUFFER_STATE *cb_state, VkPipelineBindPoint bind_point) {
     UpdateStateCmdDrawDispatchType(cb_state, bind_point);
     UpdateResourceTrackingOnDraw(cb_state);
     cb_state->hasDrawCmd = true;
@@ -85,8 +88,8 @@ void CoreChecks::PreCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t ve
     GpuAllocateValidationResources(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
 
-void CoreChecks::PostCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
-                                       uint32_t firstVertex, uint32_t firstInstance) {
+void ValidationStateTracker::PostCallRecordCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount,
+                                                   uint32_t firstVertex, uint32_t firstInstance) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     UpdateStateCmdDrawType(cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
@@ -105,6 +108,8 @@ bool CoreChecks::PreCallValidateCmdDrawIndexed(VkCommandBuffer commandBuffer, ui
             index_size = 2;
         } else if (index_buffer_binding.index_type == VK_INDEX_TYPE_UINT32) {
             index_size = 4;
+        } else if (index_buffer_binding.index_type == VK_INDEX_TYPE_UINT8_EXT) {
+            index_size = 1;
         }
         VkDeviceSize end_offset = (index_size * ((VkDeviceSize)firstIndex + indexCount)) + index_buffer_binding.offset;
         if (end_offset > index_buffer_binding.size) {
@@ -125,8 +130,9 @@ void CoreChecks::PreCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint
     GpuAllocateValidationResources(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
 
-void CoreChecks::PostCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount,
-                                              uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+void ValidationStateTracker::PostCallRecordCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
+                                                          uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset,
+                                                          uint32_t firstInstance) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     UpdateStateCmdDrawType(cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
@@ -137,7 +143,7 @@ bool CoreChecks::PreCallValidateCmdDrawIndirect(VkCommandBuffer commandBuffer, V
                                     VK_QUEUE_GRAPHICS_BIT, "VUID-vkCmdDrawIndirect-commandBuffer-cmdpool",
                                     "VUID-vkCmdDrawIndirect-renderpass", "VUID-vkCmdDrawIndirect-None-02700",
                                     "VUID-vkCmdDrawIndirect-commandBuffer-02701");
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
     skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdDrawIndirect()", "VUID-vkCmdDrawIndirect-buffer-02708");
     skip |= ValidateBufferUsageFlags(buffer_state, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, true, "VUID-vkCmdDrawIndirect-buffer-02709",
                                      "vkCmdDrawIndirect()", "VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT");
@@ -158,8 +164,8 @@ void CoreChecks::PreCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkB
     GpuAllocateValidationResources(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
 
-void CoreChecks::PostCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count,
-                                               uint32_t stride) {
+void ValidationStateTracker::PostCallRecordCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                           uint32_t count, uint32_t stride) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
     UpdateStateCmdDrawType(cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS);
@@ -172,7 +178,7 @@ bool CoreChecks::PreCallValidateCmdDrawIndexedIndirect(VkCommandBuffer commandBu
         commandBuffer, true, VK_PIPELINE_BIND_POINT_GRAPHICS, CMD_DRAWINDEXEDINDIRECT, "vkCmdDrawIndexedIndirect()",
         VK_QUEUE_GRAPHICS_BIT, "VUID-vkCmdDrawIndexedIndirect-commandBuffer-cmdpool", "VUID-vkCmdDrawIndexedIndirect-renderpass",
         "VUID-vkCmdDrawIndexedIndirect-None-02700", "VUID-vkCmdDrawIndexedIndirect-commandBuffer-02701");
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
     skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdDrawIndexedIndirect()", "VUID-vkCmdDrawIndexedIndirect-buffer-02708");
     skip |= ValidateBufferUsageFlags(buffer_state, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, true,
                                      "VUID-vkCmdDrawIndexedIndirect-buffer-02709", "vkCmdDrawIndexedIndirect()",
@@ -195,8 +201,8 @@ void CoreChecks::PreCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuff
     GpuAllocateValidationResources(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
 
-void CoreChecks::PostCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                      uint32_t count, uint32_t stride) {
+void ValidationStateTracker::PostCallRecordCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                  VkDeviceSize offset, uint32_t count, uint32_t stride) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
     UpdateStateCmdDrawType(cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS);
@@ -215,7 +221,7 @@ void CoreChecks::PreCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_
     GpuAllocateValidationResources(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE);
 }
 
-void CoreChecks::PostCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
+void ValidationStateTracker::PostCallRecordCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     UpdateStateCmdDrawDispatchType(cb_state, VK_PIPELINE_BIND_POINT_COMPUTE);
 }
@@ -225,7 +231,7 @@ bool CoreChecks::PreCallValidateCmdDispatchIndirect(VkCommandBuffer commandBuffe
         ValidateCmdDrawType(commandBuffer, false, VK_PIPELINE_BIND_POINT_COMPUTE, CMD_DISPATCHINDIRECT, "vkCmdDispatchIndirect()",
                             VK_QUEUE_COMPUTE_BIT, "VUID-vkCmdDispatchIndirect-commandBuffer-cmdpool",
                             "VUID-vkCmdDispatchIndirect-renderpass", "VUID-vkCmdDispatchIndirect-None-02700", kVUIDUndefined);
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
     skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdDispatchIndirect()", "VUID-vkCmdDispatchIndirect-buffer-02708");
     skip |=
         ValidateBufferUsageFlags(buffer_state, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, true, "VUID-vkCmdDispatchIndirect-buffer-02709",
@@ -237,7 +243,8 @@ void CoreChecks::PreCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer,
     GpuAllocateValidationResources(commandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE);
 }
 
-void CoreChecks::PostCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+void ValidationStateTracker::PostCallRecordCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                               VkDeviceSize offset) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     UpdateStateCmdDrawDispatchType(cb_state, VK_PIPELINE_BIND_POINT_COMPUTE);
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
@@ -265,7 +272,7 @@ bool CoreChecks::PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandB
     skip |= ValidateCmdDrawStrideWithStruct(commandBuffer, "VUID-vkCmdDrawIndirectCountKHR-stride-03110", stride,
                                             "VkDrawIndirectCommand", sizeof(VkDrawIndirectCommand));
     if (maxDrawCount > 1) {
-        BUFFER_STATE *buffer_state = GetBufferState(buffer);
+        const BUFFER_STATE *buffer_state = GetBufferState(buffer);
         skip |= ValidateCmdDrawStrideWithBuffer(commandBuffer, "VUID-vkCmdDrawIndirectCountKHR-maxDrawCount-03111", stride,
                                                 "VkDrawIndirectCommand", sizeof(VkDrawIndirectCommand), maxDrawCount, offset,
                                                 buffer_state);
@@ -275,8 +282,8 @@ bool CoreChecks::PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandB
                                 "vkCmdDrawIndirectCountKHR()", VK_QUEUE_GRAPHICS_BIT,
                                 "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-cmdpool", "VUID-vkCmdDrawIndirectCountKHR-renderpass",
                                 "VUID-vkCmdDrawIndirectCountKHR-None-02700", "VUID-vkCmdDrawIndirectCountKHR-commandBuffer-02701");
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
-    BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
+    const BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
     skip |=
         ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdDrawIndirectCountKHR()", "VUID-vkCmdDrawIndirectCountKHR-buffer-02708");
     skip |= ValidateMemoryIsBoundToBuffer(count_buffer_state, "vkCmdDrawIndirectCountKHR()",
@@ -290,9 +297,10 @@ bool CoreChecks::PreCallValidateCmdDrawIndirectCountKHR(VkCommandBuffer commandB
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                      VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
-                                                      uint32_t stride) {
+void ValidationStateTracker::PreCallRecordCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                  VkDeviceSize offset, VkBuffer countBuffer,
+                                                                  VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                  uint32_t stride) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
     BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
@@ -324,7 +332,7 @@ bool CoreChecks::PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer c
     skip |= ValidateCmdDrawStrideWithStruct(commandBuffer, "VUID-vkCmdDrawIndexedIndirectCountKHR-stride-03142", stride,
                                             "VkDrawIndirectCommand", sizeof(VkDrawIndexedIndirectCommand));
     if (maxDrawCount > 1) {
-        BUFFER_STATE *buffer_state = GetBufferState(buffer);
+        const BUFFER_STATE *buffer_state = GetBufferState(buffer);
         skip |= ValidateCmdDrawStrideWithBuffer(commandBuffer, "VUID-vkCmdDrawIndexedIndirectCountKHR-maxDrawCount-03143", stride,
                                                 "VkDrawIndirectCommand", sizeof(VkDrawIndexedIndirectCommand), maxDrawCount, offset,
                                                 buffer_state);
@@ -335,8 +343,8 @@ bool CoreChecks::PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer c
         VK_QUEUE_GRAPHICS_BIT, "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-cmdpool",
         "VUID-vkCmdDrawIndexedIndirectCountKHR-renderpass", "VUID-vkCmdDrawIndexedIndirectCountKHR-None-02700",
         "VUID-vkCmdDrawIndexedIndirectCountKHR-commandBuffer-02701");
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
-    BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
+    const BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
     skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdDrawIndexedIndirectCountKHR()",
                                           "VUID-vkCmdDrawIndexedIndirectCountKHR-buffer-02708");
     skip |= ValidateMemoryIsBoundToBuffer(count_buffer_state, "vkCmdDrawIndexedIndirectCountKHR()",
@@ -350,9 +358,10 @@ bool CoreChecks::PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer c
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                             VkBuffer countBuffer, VkDeviceSize countBufferOffset,
-                                                             uint32_t maxDrawCount, uint32_t stride) {
+void ValidationStateTracker::PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                         VkDeviceSize offset, VkBuffer countBuffer,
+                                                                         VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                         uint32_t stride) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
     BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
@@ -361,6 +370,28 @@ void CoreChecks::PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer com
     AddCommandBufferBindingBuffer(cb_state, count_buffer_state);
 }
 
+void CoreChecks::PreCallRecordCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+                                             VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+                                             VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+                                             VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+                                             VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+                                             VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+                                             uint32_t width, uint32_t height, uint32_t depth) {
+    GpuAllocateValidationResources(commandBuffer, VK_PIPELINE_BIND_POINT_RAY_TRACING_NV);
+}
+
+void CoreChecks::PostCallRecordCmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer,
+                                              VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer,
+                                              VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride,
+                                              VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset,
+                                              VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer,
+                                              VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride,
+                                              uint32_t width, uint32_t height, uint32_t depth) {
+    CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
+    UpdateStateCmdDrawDispatchType(cb_state, VK_PIPELINE_BIND_POINT_RAY_TRACING_NV);
+    cb_state->hasTraceRaysCmd = true;
+}
+
 bool CoreChecks::PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {
     bool skip = ValidateCmdDrawType(commandBuffer, false, VK_PIPELINE_BIND_POINT_GRAPHICS, CMD_DRAWMESHTASKSNV,
                                     "vkCmdDrawMeshTasksNV()", VK_QUEUE_GRAPHICS_BIT,
@@ -369,7 +400,8 @@ bool CoreChecks::PreCallValidateCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) {
+void ValidationStateTracker::PreCallRecordCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount,
+                                                             uint32_t firstTask) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     UpdateStateCmdDrawType(cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
@@ -381,7 +413,7 @@ bool CoreChecks::PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer comma
                                     "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-cmdpool",
                                     "VUID-vkCmdDrawMeshTasksIndirectNV-renderpass", "VUID-vkCmdDrawMeshTasksIndirectNV-None-02700",
                                     "VUID-vkCmdDrawMeshTasksIndirectNV-commandBuffer-02701");
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
     skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdDrawMeshTasksIndirectNV()",
                                           "VUID-vkCmdDrawMeshTasksIndirectNV-buffer-02708");
     skip |= ValidateBufferUsageFlags(buffer_state, VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT, true,
@@ -395,8 +427,8 @@ bool CoreChecks::PreCallValidateCmdDrawMeshTasksIndirectNV(VkCommandBuffer comma
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                         uint32_t drawCount, uint32_t stride) {
+void ValidationStateTracker::PreCallRecordCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                     VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     UpdateStateCmdDrawType(cb_state, VK_PIPELINE_BIND_POINT_GRAPHICS);
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
@@ -413,8 +445,8 @@ bool CoreChecks::PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer
         "vkCmdDrawMeshTasksIndirectCountNV()", VK_QUEUE_GRAPHICS_BIT,
         "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-cmdpool", "VUID-vkCmdDrawMeshTasksIndirectCountNV-renderpass",
         "VUID-vkCmdDrawMeshTasksIndirectCountNV-None-02700", "VUID-vkCmdDrawMeshTasksIndirectCountNV-commandBuffer-02701");
-    BUFFER_STATE *buffer_state = GetBufferState(buffer);
-    BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
+    const BUFFER_STATE *buffer_state = GetBufferState(buffer);
+    const BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
     skip |= ValidateMemoryIsBoundToBuffer(buffer_state, "vkCmdDrawMeshTasksIndirectCountNV()",
                                           "VUID-vkCmdDrawMeshTasksIndirectCountNV-buffer-02708");
     skip |= ValidateMemoryIsBoundToBuffer(count_buffer_state, "vkCmdDrawMeshTasksIndirectCountNV()",
@@ -435,9 +467,10 @@ bool CoreChecks::PreCallValidateCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer
     return skip;
 }
 
-void CoreChecks::PreCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
-                                                              VkBuffer countBuffer, VkDeviceSize countBufferOffset,
-                                                              uint32_t maxDrawCount, uint32_t stride) {
+void ValidationStateTracker::PreCallRecordCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                          VkDeviceSize offset, VkBuffer countBuffer,
+                                                                          VkDeviceSize countBufferOffset, uint32_t maxDrawCount,
+                                                                          uint32_t stride) {
     CMD_BUFFER_STATE *cb_state = GetCBState(commandBuffer);
     BUFFER_STATE *buffer_state = GetBufferState(buffer);
     BUFFER_STATE *count_buffer_state = GetBufferState(countBuffer);
diff --git a/layers/generated/chassis.cpp b/layers/generated/chassis.cpp
index 779ebdd68..9923262ea 100644
--- a/layers/generated/chassis.cpp
+++ b/layers/generated/chassis.cpp
@@ -33,10 +33,11 @@
 
 std::unordered_map<void*, ValidationObject*> layer_data_map;
 
-// Global unique object identifier.  All increments must be guarded by a lock.
-uint64_t global_unique_id = 1;
-// Map uniqueID to actual object handle
-std::unordered_map<uint64_t, uint64_t> unique_id_mapping;
+// Global unique object identifier.
+std::atomic<uint64_t> global_unique_id(1ULL);
+// Map uniqueID to actual object handle. Accesses to the map itself are
+// internally synchronized.
+vl_concurrent_unordered_map<uint64_t, uint64_t, 4> unique_id_mapping;
 
 // TODO: This variable controls handle wrapping -- in the future it should be hooked
 //       up to the new VALIDATION_FEATURES extension. Temporarily, control with a compile-time flag.
@@ -80,6 +81,9 @@ bool wrap_handles = false;
 #if BUILD_CORE_VALIDATION
 #include "core_validation.h"
 #endif
+#if BUILD_BEST_PRACTICES
+#include "best_practices.h"
+#endif
 
 namespace vulkan_layer_chassis {
 
@@ -110,7 +114,7 @@ static void InstanceExtensionWhitelist(ValidationObject *layer_data, const VkIns
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         // Check for recognized instance extensions
         if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kInstanceExtensionNames)) {
-            log_msg(layer_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+            log_msg(layer_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                     kVUIDUndefined,
                     "Instance Extension %s is not supported by this layer.  Using this extension may adversely affect validation "
                     "results and/or produce undefined behavior.",
@@ -124,7 +128,7 @@ static void DeviceExtensionWhitelist(ValidationObject *layer_data, const VkDevic
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         // Check for recognized device extensions
         if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kDeviceExtensionNames)) {
-            log_msg(layer_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+            log_msg(layer_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                     kVUIDUndefined,
                     "Device Extension %s is not supported by this layer.  Using this extension may adversely affect validation "
                     "results and/or produce undefined behavior.",
@@ -151,12 +155,17 @@ static const std::unordered_map<std::string, VkValidationFeatureEnableEXT> VkVal
     {"VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT", VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT},
 };
 
+static const std::unordered_map<std::string, VkValidationFeatureEnable> VkValFeatureEnableLookup2 = {
+    {"VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES", VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES},
+};
+
 static const std::unordered_map<std::string, ValidationCheckDisables> ValidationDisableLookup = {
     {"VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE", VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE},
     {"VALIDATION_CHECK_DISABLE_OBJECT_IN_USE", VALIDATION_CHECK_DISABLE_OBJECT_IN_USE},
     {"VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET", VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET},
     {"VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE", VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE},
     {"VALIDATION_CHECK_DISABLE_QUERY_VALIDATION", VALIDATION_CHECK_DISABLE_QUERY_VALIDATION},
+    {"VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION", VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION},
 };
 
 // Set the local disable flag for the appropriate VALIDATION_CHECK_DISABLE enum
@@ -177,6 +186,9 @@ void SetValidationDisable(CHECK_DISABLED* disable_data, const ValidationCheckDis
         case VALIDATION_CHECK_DISABLE_QUERY_VALIDATION:
             disable_data->query_validation = true;
             break;
+        case VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION:
+            disable_data->image_layout_validation = true;
+            break;
         default:
             assert(true);
     }
@@ -226,6 +238,16 @@ void SetValidationFeatureEnable(CHECK_ENABLED *enable_data, const VkValidationFe
     }
 }
 
+void SetValidationFeatureEnable(CHECK_ENABLED *enable_data, const VkValidationFeatureEnable feature_enable) {
+    switch(feature_enable) {
+        case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES:
+            enable_data->best_practices = true;
+            break;
+        default:
+            break;
+    }
+}
+
 // Set the local disable flag for settings specified through the VK_EXT_validation_flags extension
 void SetValidationFlags(CHECK_DISABLED* disables, const VkValidationFlagsEXT* val_flags_struct) {
     for (uint32_t i = 0; i < val_flags_struct->disabledValidationCheckCount; ++i) {
@@ -270,6 +292,11 @@ void SetLocalEnableSetting(std::string list_of_enables, std::string delimiter, C
             auto result = VkValFeatureEnableLookup.find(token);
             if (result != VkValFeatureEnableLookup.end()) {
                 SetValidationFeatureEnable(enables, result->second);
+            } else {
+                auto result2 = VkValFeatureEnableLookup2.find(token);
+                if (result2 != VkValFeatureEnableLookup2.end()) {
+                    SetValidationFeatureEnable(enables, result2->second);
+                }
             }
         }
         list_of_enables.erase(0, pos + delimiter.length());
@@ -441,6 +468,14 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreat
     core_checks->container_type = LayerObjectTypeCoreValidation;
     core_checks->api_version = api_version;
 #endif
+#if BUILD_BEST_PRACTICES
+    auto best_practices = new BestPractices;
+    if (local_enables.best_practices) {
+        local_object_dispatch.emplace_back(best_practices);
+    }
+    best_practices->container_type = LayerObjectTypeBestPractices;
+    best_practices->api_version = api_version;
+#endif
 
     // If handle wrapping is disabled via the ValidationFeatures extension, override build flag
     if (local_disables.handle_wrapping) {
@@ -500,6 +535,12 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreat
     core_checks->disabled = framework->disabled;
     core_checks->instance_state = core_checks;
 #endif
+#if BUILD_BEST_PRACTICES
+    best_practices->report_data = framework->report_data;
+    best_practices->instance_dispatch_table = framework->instance_dispatch_table;
+    best_practices->enabled = framework->enabled;
+    best_practices->disabled = framework->disabled;
+#endif
 
     for (auto intercept : framework->object_dispatch) {
         intercept->PostCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance, result);
@@ -575,7 +616,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice
         item->device_extensions = device_extensions;
     }
 
-    std::unique_ptr<safe_VkDeviceCreateInfo> modified_create_info(new safe_VkDeviceCreateInfo(pCreateInfo));
+    safe_VkDeviceCreateInfo modified_create_info(pCreateInfo);
 
     bool skip = false;
     for (auto intercept : instance_interceptor->object_dispatch) {
@@ -585,10 +626,10 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice
     }
     for (auto intercept : instance_interceptor->object_dispatch) {
         auto lock = intercept->write_lock();
-        intercept->PreCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice, modified_create_info);
+        intercept->PreCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice, &modified_create_info);
     }
 
-    VkResult result = fpCreateDevice(gpu, reinterpret_cast<VkDeviceCreateInfo *>(modified_create_info.get()), pAllocator, pDevice);
+    VkResult result = fpCreateDevice(gpu, reinterpret_cast<VkDeviceCreateInfo *>(&modified_create_info), pAllocator, pDevice);
     if (result != VK_SUCCESS) {
         return result;
     }
@@ -640,6 +681,13 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice
         device_interceptor->object_dispatch.emplace_back(core_checks);
     }
 #endif
+#if BUILD_BEST_PRACTICES
+    auto best_practices = new BestPractices;
+    best_practices->container_type = LayerObjectTypeBestPractices;
+    if (instance_interceptor->enabled.best_practices) {
+        device_interceptor->object_dispatch.emplace_back(best_practices);
+    }
+#endif
 
     // Set per-intercept common data items
     for (auto dev_intercept : device_interceptor->object_dispatch) {
@@ -780,25 +828,31 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     bool skip = false;
 
-#ifndef BUILD_CORE_VALIDATION
-    struct PIPELINE_STATE {};
+#ifdef BUILD_CORE_VALIDATION
+    create_ray_tracing_pipeline_api_state crtpl_state{};
+#else
+    struct create_ray_tracing_pipeline_api_state {
+        const VkRayTracingPipelineCreateInfoNV* pCreateInfos;
+    } crtpl_state;
 #endif
-
-    std::vector<std::unique_ptr<PIPELINE_STATE>> pipe_state;
+    crtpl_state.pCreateInfos = pCreateInfos;
 
     for (auto intercept : layer_data->object_dispatch) {
         auto lock = intercept->write_lock();
-        skip |= intercept->PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &pipe_state);
+        skip |= intercept->PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos,
+                                                                      pAllocator, pPipelines, &crtpl_state);
         if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
     }
     for (auto intercept : layer_data->object_dispatch) {
         auto lock = intercept->write_lock();
-        intercept->PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        intercept->PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+                                                            pPipelines, &crtpl_state);
     }
     VkResult result = DispatchCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     for (auto intercept : layer_data->object_dispatch) {
         auto lock = intercept->write_lock();
-        intercept->PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result, &pipe_state);
+        intercept->PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+                                                             pPipelines, result, &crtpl_state);
     }
     return result;
 }
@@ -6433,6 +6487,79 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
 
 
 
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties) {
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+    bool skip = false;
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        skip |= intercept->PreCallValidateGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
+        if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PreCallRecordGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
+    }
+    VkResult result = DispatchGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PostCallRecordGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties, result);
+    }
+    return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics) {
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+    bool skip = false;
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        skip |= intercept->PreCallValidateGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
+        if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PreCallRecordGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
+    }
+    VkResult result = DispatchGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PostCallRecordGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics, result);
+    }
+    return result;
+}
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+    bool skip = false;
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        skip |= intercept->PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+        if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
+    }
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PreCallRecordGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+    }
+    VkResult result = DispatchGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations, result);
+    }
+    return result;
+}
+
+
 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -7000,6 +7127,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
 
 
 
+
 VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
     VkCommandBuffer                             commandBuffer,
     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin) {
@@ -8400,6 +8528,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
 }
 
 
+
 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
     VkPhysicalDevice                            physicalDevice,
     uint32_t*                                   pTimeDomainCount,
@@ -8886,6 +9015,9 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
 
 
 
+
+
+
 VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
     VkDevice                                    device,
     const VkBufferDeviceAddressInfoEXT*         pInfo) {
@@ -9080,6 +9212,29 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
 }
 
 
+VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern) {
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+    bool skip = false;
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        skip |= intercept->PreCallValidateCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
+        if (skip) return;
+    }
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PreCallRecordCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
+    }
+    DispatchCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
+    for (auto intercept : layer_data->object_dispatch) {
+        auto lock = intercept->write_lock();
+        intercept->PostCallRecordCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
+    }
+}
+
+
 VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
@@ -9105,6 +9260,7 @@ VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
 
 
 
+
 // Map of intercepted ApiName to its associated function data
 const std::unordered_map<std::string, function_data> name_to_funcptr_map = {
     {"vkCreateInstance", {true, (void*)CreateInstance}},
@@ -9385,6 +9541,9 @@ const std::unordered_map<std::string, function_data> name_to_funcptr_map = {
     {"vkGetDescriptorSetLayoutSupportKHR", {false, (void*)GetDescriptorSetLayoutSupportKHR}},
     {"vkCmdDrawIndirectCountKHR", {false, (void*)CmdDrawIndirectCountKHR}},
     {"vkCmdDrawIndexedIndirectCountKHR", {false, (void*)CmdDrawIndexedIndirectCountKHR}},
+    {"vkGetPipelineExecutablePropertiesKHR", {false, (void*)GetPipelineExecutablePropertiesKHR}},
+    {"vkGetPipelineExecutableStatisticsKHR", {false, (void*)GetPipelineExecutableStatisticsKHR}},
+    {"vkGetPipelineExecutableInternalRepresentationsKHR", {false, (void*)GetPipelineExecutableInternalRepresentationsKHR}},
     {"vkCreateDebugReportCallbackEXT", {true, (void*)CreateDebugReportCallbackEXT}},
     {"vkDestroyDebugReportCallbackEXT", {true, (void*)DestroyDebugReportCallbackEXT}},
     {"vkDebugReportMessageEXT", {true, (void*)DebugReportMessageEXT}},
@@ -9536,6 +9695,7 @@ const std::unordered_map<std::string, function_data> name_to_funcptr_map = {
     {"vkGetDeviceGroupSurfacePresentModes2EXT", {false, (void*)GetDeviceGroupSurfacePresentModes2EXT}},
 #endif
     {"vkCreateHeadlessSurfaceEXT", {true, (void*)CreateHeadlessSurfaceEXT}},
+    {"vkCmdSetLineStippleEXT", {false, (void*)CmdSetLineStippleEXT}},
     {"vkResetQueryPoolEXT", {false, (void*)ResetQueryPoolEXT}},
 };
 
diff --git a/layers/generated/chassis.h b/layers/generated/chassis.h
index bc5367d5c..80695d78f 100644
--- a/layers/generated/chassis.h
+++ b/layers/generated/chassis.h
@@ -25,6 +25,7 @@
 
 
 #define NOMINMAX
+#include <atomic>
 #include <mutex>
 #include <cinttypes>
 #include <stdio.h>
@@ -52,8 +53,8 @@
 #include "vk_typemap_helper.h"
 
 
-extern uint64_t global_unique_id;
-extern std::unordered_map<uint64_t, uint64_t> unique_id_mapping;
+extern std::atomic<uint64_t> global_unique_id;
+extern vl_concurrent_unordered_map<uint64_t, uint64_t, 4> unique_id_mapping;
 
 
 
@@ -1535,6 +1536,25 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
 
 
 
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties);
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics);
+
+VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+
 VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -1716,6 +1736,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
 
 
 
+
 VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
     VkCommandBuffer                             commandBuffer,
     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
@@ -2127,6 +2148,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
     uint32_t                                    marker);
 
 
+
 VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
     VkPhysicalDevice                            physicalDevice,
     uint32_t*                                   pTimeDomainCount,
@@ -2261,6 +2283,9 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
 
 
 
+
+
+
 VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
     VkDevice                                    device,
     const VkBufferDeviceAddressInfoEXT*         pInfo);
@@ -2311,6 +2336,12 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
     VkSurfaceKHR*                               pSurface);
 
 
+VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
+
+
 VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
@@ -2322,6 +2353,7 @@ VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
 
 
 
+
 // Layer object type identifiers
 enum LayerObjectTypeId {
     LayerObjectTypeInstance,                    // Container for an instance dispatch object
@@ -2330,6 +2362,7 @@ enum LayerObjectTypeId {
     LayerObjectTypeParameterValidation,         // Instance or device parameter validation layer object
     LayerObjectTypeObjectTracker,               // Instance or device object tracker layer object
     LayerObjectTypeCoreValidation,              // Instance or device core validation layer object
+    LayerObjectTypeBestPractices,               // Instance or device best practices layer object
 };
 
 struct TEMPLATE_STATE {
@@ -2352,8 +2385,13 @@ typedef enum ValidationCheckDisables {
     VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET,
     VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE,
     VALIDATION_CHECK_DISABLE_QUERY_VALIDATION,
+    VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION,
 } ValidationCheckDisables;
 
+typedef enum VkValidationFeatureEnable {
+    VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES,
+} VkValidationFeatureEnable;
+
 
 // CHECK_DISABLED struct is a container for bools that can block validation checks from being performed.
 // These bools are all "false" by default meaning that all checks are enabled. Enum values can be specified
@@ -2365,6 +2403,7 @@ struct CHECK_DISABLED {
     bool idle_descriptor_set;                       // Skip check to verify that descriptor set is not in-use
     bool push_constant_range;                       // Skip push constant range checks
     bool query_validation;                          // Disable all core validation query-related checks
+    bool image_layout_validation;                   // Disable image layout validation
     bool object_tracking;                           // Disable object lifetime validation
     bool core_checks;                               // Disable core validation checks
     bool thread_safety;                             // Disable thread safety validation
@@ -2378,6 +2417,7 @@ struct CHECK_DISABLED {
 struct CHECK_ENABLED {
     bool gpu_validation;
     bool gpu_validation_reserve_binding_slot;
+    bool best_practices;
 
     void SetAll(bool value) { std::fill(&gpu_validation, &gpu_validation_reserve_binding_slot + 1, value); }
 };
@@ -2429,7 +2469,7 @@ class ValidationObject {
 
         // Handle Wrapping Data
         // Reverse map display handles
-        std::unordered_map<VkDisplayKHR, uint64_t> display_id_reverse_mapping;
+        vl_concurrent_unordered_map<VkDisplayKHR, uint64_t, 0> display_id_reverse_mapping;
         // Wrapping Descriptor Template Update structures requires access to the template createinfo structs
         std::unordered_map<uint64_t, std::unique_ptr<TEMPLATE_STATE>> desc_template_createinfo_map;
         struct SubpassesUsageStates {
@@ -2445,31 +2485,33 @@ class ValidationObject {
         std::unordered_map<VkDescriptorPool, std::unordered_set<VkDescriptorSet>> pool_descriptor_sets_map;
 
 
-        // Unwrap a handle.  Must hold lock.
+        // Unwrap a handle.
         template <typename HandleType>
         HandleType Unwrap(HandleType wrappedHandle) {
-            // TODO: don't use operator[] here.
-            return (HandleType)unique_id_mapping[reinterpret_cast<uint64_t const &>(wrappedHandle)];
+            auto iter = unique_id_mapping.find(reinterpret_cast<uint64_t const &>(wrappedHandle));
+            if (iter == unique_id_mapping.end())
+                return (HandleType)0;
+            return (HandleType)iter->second;
         }
 
-        // Wrap a newly created handle with a new unique ID, and return the new ID -- must hold lock.
+        // Wrap a newly created handle with a new unique ID, and return the new ID.
         template <typename HandleType>
         HandleType WrapNew(HandleType newlyCreatedHandle) {
             auto unique_id = global_unique_id++;
-            unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
+            unique_id_mapping.insert_or_assign(unique_id, reinterpret_cast<uint64_t const &>(newlyCreatedHandle));
             return (HandleType)unique_id;
         }
 
-        // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup. Must hold lock.
+        // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup.
         VkDisplayKHR WrapDisplay(VkDisplayKHR newlyCreatedHandle, ValidationObject *map_data) {
             auto unique_id = global_unique_id++;
-            unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
-            map_data->display_id_reverse_mapping[newlyCreatedHandle] = unique_id;
+            unique_id_mapping.insert_or_assign(unique_id, reinterpret_cast<uint64_t const &>(newlyCreatedHandle));
+            map_data->display_id_reverse_mapping.insert_or_assign(newlyCreatedHandle, unique_id);
             return (VkDisplayKHR)unique_id;
         }
 
         // VkDisplayKHR objects don't have a single point of creation, so we need to see if one already exists in the map before
-        // creating another. Must hold lock.
+        // creating another.
         VkDisplayKHR MaybeWrapDisplay(VkDisplayKHR handle, ValidationObject *map_data) {
             // See if this display is already known
             auto it = map_data->display_id_reverse_mapping.find(handle);
@@ -3253,6 +3295,15 @@ class ValidationObject {
         virtual bool PreCallValidateCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride)  { return false; };
         virtual void PreCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
         virtual void PostCallRecordCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {};
+        virtual bool PreCallValidateGetPipelineExecutablePropertiesKHR(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties)  { return false; };
+        virtual void PreCallRecordGetPipelineExecutablePropertiesKHR(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) {};
+        virtual void PostCallRecordGetPipelineExecutablePropertiesKHR(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties, VkResult result) {};
+        virtual bool PreCallValidateGetPipelineExecutableStatisticsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics)  { return false; };
+        virtual void PreCallRecordGetPipelineExecutableStatisticsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) {};
+        virtual void PostCallRecordGetPipelineExecutableStatisticsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics, VkResult result) {};
+        virtual bool PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)  { return false; };
+        virtual void PreCallRecordGetPipelineExecutableInternalRepresentationsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {};
+        virtual void PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations, VkResult result) {};
         virtual bool PreCallValidateCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback)  { return false; };
         virtual void PreCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) {};
         virtual void PostCallRecordCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback, VkResult result) {};
@@ -3610,6 +3661,9 @@ class ValidationObject {
         virtual bool PreCallValidateCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface)  { return false; };
         virtual void PreCallRecordCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) {};
         virtual void PostCallRecordCreateHeadlessSurfaceEXT(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface, VkResult result) {};
+        virtual bool PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern)  { return false; };
+        virtual void PreCallRecordCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {};
+        virtual void PostCallRecordCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {};
         virtual bool PreCallValidateResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)  { return false; };
         virtual void PreCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
         virtual void PostCallRecordResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {};
@@ -3619,7 +3673,7 @@ class ValidationObject {
         virtual VkResult CoreLayerMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)  { return VK_SUCCESS; };
         virtual VkResult CoreLayerGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)  { return VK_SUCCESS; };
 
-        // Allow additional parameter for CreateGraphicsPipelines
+        // Allow additional state parameter for CreateGraphicsPipelines
         virtual bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state) {
             return PreCallValidateCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         };
@@ -3629,13 +3683,14 @@ class ValidationObject {
         virtual void PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* cgpl_state) {
             PostCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
         };
-        virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
-            PreCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        };
+
         // Allow additional state parameter for CreateComputePipelines
         virtual bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state)  {
             return PreCallValidateCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         };
+        virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
+            PreCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        };
         virtual void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
             PostCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
         };
@@ -3644,6 +3699,9 @@ class ValidationObject {
         virtual bool PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state)  {
             return PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         };
+        virtual void PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
+            PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        };
         virtual void PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
             PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
         };
@@ -3673,7 +3731,7 @@ class ValidationObject {
         };
 
         // Modify a parameter to CreateDevice
-        virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, std::unique_ptr<safe_VkDeviceCreateInfo> &modified_create_info) {
+        virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, safe_VkDeviceCreateInfo *modified_create_info) {
             PreCallRecordCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
         };
 };
diff --git a/layers/generated/layer_chassis_dispatch.cpp b/layers/generated/layer_chassis_dispatch.cpp
index 04d6ff45d..36b6f9e3f 100644
--- a/layers/generated/layer_chassis_dispatch.cpp
+++ b/layers/generated/layer_chassis_dispatch.cpp
@@ -30,343 +30,29 @@
 // This intentionally includes a cpp file
 #include "vk_safe_struct.cpp"
 
-std::mutex dispatch_lock;
+// shared_mutex support added in MSVC 2015 update 2
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2
+    #include <shared_mutex>
+    typedef std::shared_mutex dispatch_lock_t;
+    typedef std::shared_lock<dispatch_lock_t> read_dispatch_lock_guard_t;
+    typedef std::unique_lock<dispatch_lock_t> write_dispatch_lock_guard_t;
+#else
+    typedef std::mutex dispatch_lock_t;
+    typedef std::unique_lock<dispatch_lock_t> read_dispatch_lock_guard_t;
+    typedef std::unique_lock<dispatch_lock_t> write_dispatch_lock_guard_t;
+#endif
+dispatch_lock_t dispatch_lock;
 
 // Unique Objects pNext extension handling function
-void *CreateUnwrappedExtensionStructs(ValidationObject *layer_data, const void *pNext) {
+void WrapPnextChainHandles(ValidationObject *layer_data, const void *pNext) {
     void *cur_pnext = const_cast<void *>(pNext);
-    void *head_pnext = NULL;
-    void *prev_ext_struct = NULL;
-    void *cur_ext_struct = NULL;
-
     while (cur_pnext != NULL) {
         VkBaseOutStructure *header = reinterpret_cast<VkBaseOutStructure *>(cur_pnext);
 
         switch (header->sType) {
-            case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
-                    safe_VkDebugReportCallbackCreateInfoEXT *safe_struct = new safe_VkDebugReportCallbackCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
-                    safe_VkDebugUtilsMessengerCreateInfoEXT *safe_struct = new safe_VkDebugUtilsMessengerCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: {
-                    safe_VkValidationFeaturesEXT *safe_struct = new safe_VkValidationFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkValidationFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: {
-                    safe_VkValidationFlagsEXT *safe_struct = new safe_VkValidationFlagsEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkValidationFlagsEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: {
-                    safe_VkDeviceQueueGlobalPriorityCreateInfoEXT *safe_struct = new safe_VkDeviceQueueGlobalPriorityCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: {
-                    safe_VkDeviceGroupDeviceCreateInfo *safe_struct = new safe_VkDeviceGroupDeviceCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
-                    safe_VkDeviceMemoryOverallocationCreateInfoAMD *safe_struct = new safe_VkDeviceMemoryOverallocationCreateInfoAMD;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: {
-                    safe_VkPhysicalDevice16BitStorageFeatures *safe_struct = new safe_VkPhysicalDevice16BitStorageFeatures;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: {
-                    safe_VkPhysicalDevice8BitStorageFeaturesKHR *safe_struct = new safe_VkPhysicalDevice8BitStorageFeaturesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceASTCDecodeFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: {
-                    safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *safe_struct = new safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: {
-                    safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV *safe_struct = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: {
-                    safe_VkPhysicalDeviceCornerSampledImageFeaturesNV *safe_struct = new safe_VkPhysicalDeviceCornerSampledImageFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: {
-                    safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV *safe_struct = new safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: {
-                    safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *safe_struct = new safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: {
-                    safe_VkPhysicalDeviceExclusiveScissorFeaturesNV *safe_struct = new safe_VkPhysicalDeviceExclusiveScissorFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: {
-                    safe_VkPhysicalDeviceFeatures2 *safe_struct = new safe_VkPhysicalDeviceFeatures2;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceFeatures2 *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: {
-                    safe_VkPhysicalDeviceFloat16Int8FeaturesKHR *safe_struct = new safe_VkPhysicalDeviceFloat16Int8FeaturesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceFloat16Int8FeaturesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: {
-                    safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *safe_struct = new safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceHostQueryResetFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceHostQueryResetFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: {
-                    safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR *safe_struct = new safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeaturesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: {
-                    safe_VkPhysicalDeviceMeshShaderFeaturesNV *safe_struct = new safe_VkPhysicalDeviceMeshShaderFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: {
-                    safe_VkPhysicalDeviceMultiviewFeatures *safe_struct = new safe_VkPhysicalDeviceMultiviewFeatures;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: {
-                    safe_VkPhysicalDeviceProtectedMemoryFeatures *safe_struct = new safe_VkPhysicalDeviceProtectedMemoryFeatures;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: {
-                    safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *safe_struct = new safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: {
-                    safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures *safe_struct = new safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: {
-                    safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *safe_struct = new safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: {
-                    safe_VkPhysicalDeviceShaderDrawParametersFeatures *safe_struct = new safe_VkPhysicalDeviceShaderDrawParametersFeatures;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: {
-                    safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV *safe_struct = new safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL: {
-                    safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL *safe_struct = new safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2INTEL *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: {
-                    safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *safe_struct = new safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: {
-                    safe_VkPhysicalDeviceShadingRateImageFeaturesNV *safe_struct = new safe_VkPhysicalDeviceShadingRateImageFeaturesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: {
-                    safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *safe_struct = new safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: {
-                    safe_VkPhysicalDeviceVariablePointersFeatures *safe_struct = new safe_VkPhysicalDeviceVariablePointersFeatures;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: {
-                    safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *safe_struct = new safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: {
-                    safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *safe_struct = new safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: {
-                    safe_VkD3D12FenceSubmitInfoKHR *safe_struct = new safe_VkD3D12FenceSubmitInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: {
-                    safe_VkDeviceGroupSubmitInfo *safe_struct = new safe_VkDeviceGroupSubmitInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceGroupSubmitInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: {
-                    safe_VkProtectedSubmitInfo *safe_struct = new safe_VkProtectedSubmitInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkProtectedSubmitInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
 #ifdef VK_USE_PLATFORM_WIN32_KHR 
             case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: {
-                    safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *safe_struct = new safe_VkWin32KeyedMutexAcquireReleaseInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>(cur_pnext));
+                    safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *safe_struct = reinterpret_cast<safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *>(cur_pnext);
                     if (safe_struct->pAcquireSyncs) {
                         for (uint32_t index0 = 0; index0 < safe_struct->acquireCount; ++index0) {
                             safe_struct->pAcquireSyncs[index0] = layer_data->Unwrap(safe_struct->pAcquireSyncs[index0]);
@@ -377,14 +63,12 @@ void *CreateUnwrappedExtensionStructs(ValidationObject *layer_data, const void *
                             safe_struct->pReleaseSyncs[index0] = layer_data->Unwrap(safe_struct->pReleaseSyncs[index0]);
                         }
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 #endif // VK_USE_PLATFORM_WIN32_KHR 
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR 
             case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: {
-                    safe_VkWin32KeyedMutexAcquireReleaseInfoNV *safe_struct = new safe_VkWin32KeyedMutexAcquireReleaseInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>(cur_pnext));
+                    safe_VkWin32KeyedMutexAcquireReleaseInfoNV *safe_struct = reinterpret_cast<safe_VkWin32KeyedMutexAcquireReleaseInfoNV *>(cur_pnext);
                     if (safe_struct->pAcquireSyncs) {
                         for (uint32_t index0 = 0; index0 < safe_struct->acquireCount; ++index0) {
                             safe_struct->pAcquireSyncs[index0] = layer_data->Unwrap(safe_struct->pAcquireSyncs[index0]);
@@ -395,1687 +79,82 @@ void *CreateUnwrappedExtensionStructs(ValidationObject *layer_data, const void *
                             safe_struct->pReleaseSyncs[index0] = layer_data->Unwrap(safe_struct->pReleaseSyncs[index0]);
                         }
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 #endif // VK_USE_PLATFORM_WIN32_KHR 
 
             case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: {
-                    safe_VkDedicatedAllocationMemoryAllocateInfoNV *safe_struct = new safe_VkDedicatedAllocationMemoryAllocateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>(cur_pnext));
+                    safe_VkDedicatedAllocationMemoryAllocateInfoNV *safe_struct = reinterpret_cast<safe_VkDedicatedAllocationMemoryAllocateInfoNV *>(cur_pnext);
                     if (safe_struct->image) {
                         safe_struct->image = layer_data->Unwrap(safe_struct->image);
                     }
                     if (safe_struct->buffer) {
                         safe_struct->buffer = layer_data->Unwrap(safe_struct->buffer);
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
-                    safe_VkExportMemoryAllocateInfo *safe_struct = new safe_VkExportMemoryAllocateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkExportMemoryAllocateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
-                    safe_VkExportMemoryAllocateInfoNV *safe_struct = new safe_VkExportMemoryAllocateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkExportMemoryAllocateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
-                    safe_VkExportMemoryWin32HandleInfoKHR *safe_struct = new safe_VkExportMemoryWin32HandleInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
-                    safe_VkExportMemoryWin32HandleInfoNV *safe_struct = new safe_VkExportMemoryWin32HandleInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: {
-                    safe_VkImportAndroidHardwareBufferInfoANDROID *safe_struct = new safe_VkImportAndroidHardwareBufferInfoANDROID;
-                    safe_struct->initialize(reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
-                    safe_VkImportMemoryFdInfoKHR *safe_struct = new safe_VkImportMemoryFdInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkImportMemoryFdInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
-                    safe_VkImportMemoryHostPointerInfoEXT *safe_struct = new safe_VkImportMemoryHostPointerInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
-                    safe_VkImportMemoryWin32HandleInfoKHR *safe_struct = new safe_VkImportMemoryWin32HandleInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
-                    safe_VkImportMemoryWin32HandleInfoNV *safe_struct = new safe_VkImportMemoryWin32HandleInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
-                    safe_VkMemoryAllocateFlagsInfo *safe_struct = new safe_VkMemoryAllocateFlagsInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkMemoryAllocateFlagsInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
             case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: {
-                    safe_VkMemoryDedicatedAllocateInfo *safe_struct = new safe_VkMemoryDedicatedAllocateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>(cur_pnext));
+                    safe_VkMemoryDedicatedAllocateInfo *safe_struct = reinterpret_cast<safe_VkMemoryDedicatedAllocateInfo *>(cur_pnext);
                     if (safe_struct->image) {
                         safe_struct->image = layer_data->Unwrap(safe_struct->image);
                     }
                     if (safe_struct->buffer) {
                         safe_struct->buffer = layer_data->Unwrap(safe_struct->buffer);
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: {
-                    safe_VkMemoryPriorityAllocateInfoEXT *safe_struct = new safe_VkMemoryPriorityAllocateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: {
-                    safe_VkDeviceGroupBindSparseInfo *safe_struct = new safe_VkDeviceGroupBindSparseInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceGroupBindSparseInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
-                    safe_VkExportFenceCreateInfo *safe_struct = new safe_VkExportFenceCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkExportFenceCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: {
-                    safe_VkExportFenceWin32HandleInfoKHR *safe_struct = new safe_VkExportFenceWin32HandleInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkExportFenceWin32HandleInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
-                    safe_VkExportSemaphoreCreateInfo *safe_struct = new safe_VkExportSemaphoreCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkExportSemaphoreCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: {
-                    safe_VkExportSemaphoreWin32HandleInfoKHR *safe_struct = new safe_VkExportSemaphoreWin32HandleInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: {
-                    safe_VkBufferDeviceAddressCreateInfoEXT *safe_struct = new safe_VkBufferDeviceAddressCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: {
-                    safe_VkDedicatedAllocationBufferCreateInfoNV *safe_struct = new safe_VkDedicatedAllocationBufferCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
-                    safe_VkExternalMemoryBufferCreateInfo *safe_struct = new safe_VkExternalMemoryBufferCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: {
-                    safe_VkDedicatedAllocationImageCreateInfoNV *safe_struct = new safe_VkDedicatedAllocationImageCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: {
-                    safe_VkExternalFormatANDROID *safe_struct = new safe_VkExternalFormatANDROID;
-                    safe_struct->initialize(reinterpret_cast<const VkExternalFormatANDROID *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
-                    safe_VkExternalMemoryImageCreateInfo *safe_struct = new safe_VkExternalMemoryImageCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkExternalMemoryImageCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
-                    safe_VkExternalMemoryImageCreateInfoNV *safe_struct = new safe_VkExternalMemoryImageCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: {
-                    safe_VkImageDrmFormatModifierExplicitCreateInfoEXT *safe_struct = new safe_VkImageDrmFormatModifierExplicitCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: {
-                    safe_VkImageDrmFormatModifierListCreateInfoEXT *safe_struct = new safe_VkImageDrmFormatModifierListCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR: {
-                    safe_VkImageFormatListCreateInfoKHR *safe_struct = new safe_VkImageFormatListCreateInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkImageFormatListCreateInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: {
-                    safe_VkImageStencilUsageCreateInfoEXT *safe_struct = new safe_VkImageStencilUsageCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkImageStencilUsageCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
             case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: {
-                    safe_VkImageSwapchainCreateInfoKHR *safe_struct = new safe_VkImageSwapchainCreateInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>(cur_pnext));
+                    safe_VkImageSwapchainCreateInfoKHR *safe_struct = reinterpret_cast<safe_VkImageSwapchainCreateInfoKHR *>(cur_pnext);
                     if (safe_struct->swapchain) {
                         safe_struct->swapchain = layer_data->Unwrap(safe_struct->swapchain);
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
-                    safe_VkImageViewASTCDecodeModeEXT *safe_struct = new safe_VkImageViewASTCDecodeModeEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
-                    safe_VkImageViewUsageCreateInfo *safe_struct = new safe_VkImageViewUsageCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkImageViewUsageCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
             case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: {
-                    safe_VkSamplerYcbcrConversionInfo *safe_struct = new safe_VkSamplerYcbcrConversionInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(cur_pnext));
+                    safe_VkSamplerYcbcrConversionInfo *safe_struct = reinterpret_cast<safe_VkSamplerYcbcrConversionInfo *>(cur_pnext);
                     if (safe_struct->conversion) {
                         safe_struct->conversion = layer_data->Unwrap(safe_struct->conversion);
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
             case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: {
-                    safe_VkShaderModuleValidationCacheCreateInfoEXT *safe_struct = new safe_VkShaderModuleValidationCacheCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT *>(cur_pnext));
+                    safe_VkShaderModuleValidationCacheCreateInfoEXT *safe_struct = reinterpret_cast<safe_VkShaderModuleValidationCacheCreateInfoEXT *>(cur_pnext);
                     if (safe_struct->validationCache) {
                         safe_struct->validationCache = layer_data->Unwrap(safe_struct->validationCache);
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: {
-                    safe_VkPipelineVertexInputDivisorStateCreateInfoEXT *safe_struct = new safe_VkPipelineVertexInputDivisorStateCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: {
-                    safe_VkPipelineTessellationDomainOriginStateCreateInfo *safe_struct = new safe_VkPipelineTessellationDomainOriginStateCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *safe_struct = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV *safe_struct = new safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineViewportShadingRateImageStateCreateInfoNV *safe_struct = new safe_VkPipelineViewportShadingRateImageStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineViewportSwizzleStateCreateInfoNV *safe_struct = new safe_VkPipelineViewportSwizzleStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineViewportWScalingStateCreateInfoNV *safe_struct = new safe_VkPipelineViewportWScalingStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: {
-                    safe_VkPipelineRasterizationConservativeStateCreateInfoEXT *safe_struct = new safe_VkPipelineRasterizationConservativeStateCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: {
-                    safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT *safe_struct = new safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: {
-                    safe_VkPipelineRasterizationStateRasterizationOrderAMD *safe_struct = new safe_VkPipelineRasterizationStateRasterizationOrderAMD;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: {
-                    safe_VkPipelineRasterizationStateStreamCreateInfoEXT *safe_struct = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineCoverageModulationStateCreateInfoNV *safe_struct = new safe_VkPipelineCoverageModulationStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineCoverageReductionStateCreateInfoNV *safe_struct = new safe_VkPipelineCoverageReductionStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineCoverageToColorStateCreateInfoNV *safe_struct = new safe_VkPipelineCoverageToColorStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: {
-                    safe_VkPipelineSampleLocationsStateCreateInfoEXT *safe_struct = new safe_VkPipelineSampleLocationsStateCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: {
-                    safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT *safe_struct = new safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: {
-                    safe_VkPipelineCreationFeedbackCreateInfoEXT *safe_struct = new safe_VkPipelineCreationFeedbackCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: {
-                    safe_VkPipelineDiscardRectangleStateCreateInfoEXT *safe_struct = new safe_VkPipelineDiscardRectangleStateCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: {
-                    safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV *safe_struct = new safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: {
-                    safe_VkSamplerReductionModeCreateInfoEXT *safe_struct = new safe_VkSamplerReductionModeCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: {
-                    safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *safe_struct = new safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: {
-                    safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT *safe_struct = new safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: {
-                    safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT *safe_struct = new safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
             case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: {
-                    safe_VkWriteDescriptorSetAccelerationStructureNV *safe_struct = new safe_VkWriteDescriptorSetAccelerationStructureNV;
-                    safe_struct->initialize(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(cur_pnext));
+                    safe_VkWriteDescriptorSetAccelerationStructureNV *safe_struct = reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureNV *>(cur_pnext);
                     if (safe_struct->pAccelerationStructures) {
                         for (uint32_t index0 = 0; index0 < safe_struct->accelerationStructureCount; ++index0) {
                             safe_struct->pAccelerationStructures[index0] = layer_data->Unwrap(safe_struct->pAccelerationStructures[index0]);
                         }
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: {
-                    safe_VkWriteDescriptorSetInlineUniformBlockEXT *safe_struct = new safe_VkWriteDescriptorSetInlineUniformBlockEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: {
-                    safe_VkFramebufferAttachmentsCreateInfoKHR *safe_struct = new safe_VkFramebufferAttachmentsCreateInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkFramebufferAttachmentsCreateInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: {
-                    safe_VkRenderPassFragmentDensityMapCreateInfoEXT *safe_struct = new safe_VkRenderPassFragmentDensityMapCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: {
-                    safe_VkRenderPassInputAttachmentAspectCreateInfo *safe_struct = new safe_VkRenderPassInputAttachmentAspectCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: {
-                    safe_VkRenderPassMultiviewCreateInfo *safe_struct = new safe_VkRenderPassMultiviewCreateInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: {
-                    safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT *safe_struct = new safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: {
-                    safe_VkDeviceGroupCommandBufferBeginInfo *safe_struct = new safe_VkDeviceGroupCommandBufferBeginInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
-                    safe_VkSampleLocationsInfoEXT *safe_struct = new safe_VkSampleLocationsInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkSampleLocationsInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: {
-                    safe_VkDeviceGroupRenderPassBeginInfo *safe_struct = new safe_VkDeviceGroupRenderPassBeginInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
             case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: {
-                    safe_VkRenderPassAttachmentBeginInfoKHR *safe_struct = new safe_VkRenderPassAttachmentBeginInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkRenderPassAttachmentBeginInfoKHR *>(cur_pnext));
+                    safe_VkRenderPassAttachmentBeginInfoKHR *safe_struct = reinterpret_cast<safe_VkRenderPassAttachmentBeginInfoKHR *>(cur_pnext);
                     if (safe_struct->pAttachments) {
                         for (uint32_t index0 = 0; index0 < safe_struct->attachmentCount; ++index0) {
                             safe_struct->pAttachments[index0] = layer_data->Unwrap(safe_struct->pAttachments[index0]);
                         }
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: {
-                    safe_VkRenderPassSampleLocationsBeginInfoEXT *safe_struct = new safe_VkRenderPassSampleLocationsBeginInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: {
-                    safe_VkBindBufferMemoryDeviceGroupInfo *safe_struct = new safe_VkBindBufferMemoryDeviceGroupInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: {
-                    safe_VkBindImageMemoryDeviceGroupInfo *safe_struct = new safe_VkBindImageMemoryDeviceGroupInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
             case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: {
-                    safe_VkBindImageMemorySwapchainInfoKHR *safe_struct = new safe_VkBindImageMemorySwapchainInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>(cur_pnext));
+                    safe_VkBindImageMemorySwapchainInfoKHR *safe_struct = reinterpret_cast<safe_VkBindImageMemorySwapchainInfoKHR *>(cur_pnext);
                     if (safe_struct->swapchain) {
                         safe_struct->swapchain = layer_data->Unwrap(safe_struct->swapchain);
                     }
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
-                    safe_VkBindImagePlaneMemoryInfo *safe_struct = new safe_VkBindImagePlaneMemoryInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkBindImagePlaneMemoryInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
-                    safe_VkImagePlaneMemoryRequirementsInfo *safe_struct = new safe_VkImagePlaneMemoryRequirementsInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: {
-                    safe_VkMemoryDedicatedRequirements *safe_struct = new safe_VkMemoryDedicatedRequirements;
-                    safe_struct->initialize(reinterpret_cast<const VkMemoryDedicatedRequirements *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: {
-                    safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV *safe_struct = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: {
-                    safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR *safe_struct = new safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceDepthStencilResolvePropertiesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT *safe_struct = new safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: {
-                    safe_VkPhysicalDeviceDriverPropertiesKHR *safe_struct = new safe_VkPhysicalDeviceDriverPropertiesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceDriverPropertiesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: {
-                    safe_VkPhysicalDeviceFloatControlsPropertiesKHR *safe_struct = new safe_VkPhysicalDeviceFloatControlsPropertiesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceFloatControlsPropertiesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: {
-                    safe_VkPhysicalDeviceIDProperties *safe_struct = new safe_VkPhysicalDeviceIDProperties;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceIDProperties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: {
-                    safe_VkPhysicalDeviceMaintenance3Properties *safe_struct = new safe_VkPhysicalDeviceMaintenance3Properties;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: {
-                    safe_VkPhysicalDeviceMeshShaderPropertiesNV *safe_struct = new safe_VkPhysicalDeviceMeshShaderPropertiesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: {
-                    safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *safe_struct = new safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: {
-                    safe_VkPhysicalDeviceMultiviewProperties *safe_struct = new safe_VkPhysicalDeviceMultiviewProperties;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: {
-                    safe_VkPhysicalDevicePCIBusInfoPropertiesEXT *safe_struct = new safe_VkPhysicalDevicePCIBusInfoPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
-                    safe_VkPhysicalDevicePointClippingProperties *safe_struct = new safe_VkPhysicalDevicePointClippingProperties;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: {
-                    safe_VkPhysicalDeviceProtectedMemoryProperties *safe_struct = new safe_VkPhysicalDeviceProtectedMemoryProperties;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: {
-                    safe_VkPhysicalDevicePushDescriptorPropertiesKHR *safe_struct = new safe_VkPhysicalDevicePushDescriptorPropertiesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: {
-                    safe_VkPhysicalDeviceRayTracingPropertiesNV *safe_struct = new safe_VkPhysicalDeviceRayTracingPropertiesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceSampleLocationsPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceSampleLocationsPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: {
-                    safe_VkPhysicalDeviceShaderCorePropertiesAMD *safe_struct = new safe_VkPhysicalDeviceShaderCorePropertiesAMD;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: {
-                    safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *safe_struct = new safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: {
-                    safe_VkPhysicalDeviceShadingRateImagePropertiesNV *safe_struct = new safe_VkPhysicalDeviceShadingRateImagePropertiesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: {
-                    safe_VkPhysicalDeviceSubgroupProperties *safe_struct = new safe_VkPhysicalDeviceSubgroupProperties;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: {
-                    safe_VkDrmFormatModifierPropertiesListEXT *safe_struct = new safe_VkDrmFormatModifierPropertiesListEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: {
-                    safe_VkAndroidHardwareBufferUsageANDROID *safe_struct = new safe_VkAndroidHardwareBufferUsageANDROID;
-                    safe_struct->initialize(reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: {
-                    safe_VkExternalImageFormatProperties *safe_struct = new safe_VkExternalImageFormatProperties;
-                    safe_struct->initialize(reinterpret_cast<const VkExternalImageFormatProperties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: {
-                    safe_VkFilterCubicImageViewImageFormatPropertiesEXT *safe_struct = new safe_VkFilterCubicImageViewImageFormatPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: {
-                    safe_VkSamplerYcbcrConversionImageFormatProperties *safe_struct = new safe_VkSamplerYcbcrConversionImageFormatProperties;
-                    safe_struct->initialize(reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: {
-                    safe_VkTextureLODGatherFormatPropertiesAMD *safe_struct = new safe_VkTextureLODGatherFormatPropertiesAMD;
-                    safe_struct->initialize(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
-                    safe_VkPhysicalDeviceExternalImageFormatInfo *safe_struct = new safe_VkPhysicalDeviceExternalImageFormatInfo;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: {
-                    safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT *safe_struct = new safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: {
-                    safe_VkPhysicalDeviceImageViewImageFormatInfoEXT *safe_struct = new safe_VkPhysicalDeviceImageViewImageFormatInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: {
-                    safe_VkQueueFamilyCheckpointPropertiesNV *safe_struct = new safe_VkQueueFamilyCheckpointPropertiesNV;
-                    safe_struct->initialize(reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: {
-                    safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *safe_struct = new safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: {
-                    safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *safe_struct = new safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
-                    safe_VkDeviceGroupSwapchainCreateInfoKHR *safe_struct = new safe_VkDeviceGroupSwapchainCreateInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: {
-                    safe_VkSurfaceFullScreenExclusiveInfoEXT *safe_struct = new safe_VkSurfaceFullScreenExclusiveInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: {
-                    safe_VkSurfaceFullScreenExclusiveWin32InfoEXT *safe_struct = new safe_VkSurfaceFullScreenExclusiveWin32InfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
-                    safe_VkSwapchainCounterCreateInfoEXT *safe_struct = new safe_VkSwapchainCounterCreateInfoEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: {
-                    safe_VkSwapchainDisplayNativeHdrCreateInfoAMD *safe_struct = new safe_VkSwapchainDisplayNativeHdrCreateInfoAMD;
-                    safe_struct->initialize(reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: {
-                    safe_VkDeviceGroupPresentInfoKHR *safe_struct = new safe_VkDeviceGroupPresentInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: {
-                    safe_VkDisplayPresentInfoKHR *safe_struct = new safe_VkDisplayPresentInfoKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkDisplayPresentInfoKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_GGP 
-            case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: {
-                    safe_VkPresentFrameTokenGGP *safe_struct = new safe_VkPresentFrameTokenGGP;
-                    safe_struct->initialize(reinterpret_cast<const VkPresentFrameTokenGGP *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_GGP 
-
-            case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: {
-                    safe_VkPresentRegionsKHR *safe_struct = new safe_VkPresentRegionsKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkPresentRegionsKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: {
-                    safe_VkPresentTimesInfoGOOGLE *safe_struct = new safe_VkPresentTimesInfoGOOGLE;
-                    safe_struct->initialize(reinterpret_cast<const VkPresentTimesInfoGOOGLE *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: {
-                    safe_VkSubpassDescriptionDepthStencilResolveKHR *safe_struct = new safe_VkSubpassDescriptionDepthStencilResolveKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkSubpassDescriptionDepthStencilResolveKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: {
-                    safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD *safe_struct = new safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD;
-                    safe_struct->initialize(reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-            case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: {
-                    safe_VkSharedPresentSurfaceCapabilitiesKHR *safe_struct = new safe_VkSharedPresentSurfaceCapabilitiesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
                 } break;
 
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: {
-                    safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT *safe_struct = new safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT;
-                    safe_struct->initialize(reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: {
-                    safe_VkSurfaceProtectedCapabilitiesKHR *safe_struct = new safe_VkSurfaceProtectedCapabilitiesKHR;
-                    safe_struct->initialize(reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: {
-                    safe_VkAndroidHardwareBufferFormatPropertiesANDROID *safe_struct = new safe_VkAndroidHardwareBufferFormatPropertiesANDROID;
-                    safe_struct->initialize(reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>(cur_pnext));
-                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);
-                } break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
             default:
                 break;
         }
 
-        // Save pointer to the first structure in the pNext chain
-        head_pnext = (head_pnext ? head_pnext : cur_ext_struct);
-
-        // For any extension structure but the first, link the last struct's pNext to the current ext struct
-        if (prev_ext_struct) {
-                reinterpret_cast<VkBaseOutStructure *>(prev_ext_struct)->pNext = reinterpret_cast<VkBaseOutStructure *>(cur_ext_struct);
-        }
-        prev_ext_struct = cur_ext_struct;
-
         // Process the next structure in the chain
         cur_pnext = header->pNext;
     }
-    return head_pnext;
-}
-
-// Free a pNext extension chain
-void FreeUnwrappedExtensionStructs(void *head) {
-    VkBaseOutStructure *curr_ptr = reinterpret_cast<VkBaseOutStructure *>(head);
-    while (curr_ptr) {
-        VkBaseOutStructure *header = curr_ptr;
-        curr_ptr = reinterpret_cast<VkBaseOutStructure *>(header->pNext);
-
-        switch (header->sType) {
-            case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkDebugReportCallbackCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkDebugUtilsMessengerCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkValidationFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
-                delete reinterpret_cast<safe_VkValidationFlagsEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkDeviceQueueGlobalPriorityCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
-                delete reinterpret_cast<safe_VkDeviceGroupDeviceCreateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
-                delete reinterpret_cast<safe_VkDeviceMemoryOverallocationCreateInfoAMD *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
-                delete reinterpret_cast<safe_VkPhysicalDevice16BitStorageFeatures *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDevice8BitStorageFeaturesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceCornerSampledImageFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceExclusiveScissorFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
-                delete reinterpret_cast<safe_VkPhysicalDeviceFeatures2 *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceFloat16Int8FeaturesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceHostQueryResetFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewFeatures *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceProtectedMemoryFeatures *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShadingRateImageFeaturesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceVariablePointersFeatures *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
-                delete reinterpret_cast<safe_VkD3D12FenceSubmitInfoKHR *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
-                delete reinterpret_cast<safe_VkDeviceGroupSubmitInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
-                delete reinterpret_cast<safe_VkProtectedSubmitInfo *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
-                delete reinterpret_cast<safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
-                delete reinterpret_cast<safe_VkWin32KeyedMutexAcquireReleaseInfoNV *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
-                delete reinterpret_cast<safe_VkDedicatedAllocationMemoryAllocateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
-                delete reinterpret_cast<safe_VkExportMemoryAllocateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
-                delete reinterpret_cast<safe_VkExportMemoryAllocateInfoNV *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-                delete reinterpret_cast<safe_VkExportMemoryWin32HandleInfoKHR *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
-                delete reinterpret_cast<safe_VkExportMemoryWin32HandleInfoNV *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
-                delete reinterpret_cast<safe_VkImportAndroidHardwareBufferInfoANDROID *>(header);
-                break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
-                delete reinterpret_cast<safe_VkImportMemoryFdInfoKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
-                delete reinterpret_cast<safe_VkImportMemoryHostPointerInfoEXT *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
-                delete reinterpret_cast<safe_VkImportMemoryWin32HandleInfoKHR *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
-                delete reinterpret_cast<safe_VkImportMemoryWin32HandleInfoNV *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
-                delete reinterpret_cast<safe_VkMemoryAllocateFlagsInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
-                delete reinterpret_cast<safe_VkMemoryDedicatedAllocateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkMemoryPriorityAllocateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
-                delete reinterpret_cast<safe_VkDeviceGroupBindSparseInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
-                delete reinterpret_cast<safe_VkExportFenceCreateInfo *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
-                delete reinterpret_cast<safe_VkExportFenceWin32HandleInfoKHR *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
-                delete reinterpret_cast<safe_VkExportSemaphoreCreateInfo *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
-                delete reinterpret_cast<safe_VkExportSemaphoreWin32HandleInfoKHR *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkBufferDeviceAddressCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkDedicatedAllocationBufferCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
-                delete reinterpret_cast<safe_VkExternalMemoryBufferCreateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkDedicatedAllocationImageCreateInfoNV *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
-                delete reinterpret_cast<safe_VkExternalFormatANDROID *>(header);
-                break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
-                delete reinterpret_cast<safe_VkExternalMemoryImageCreateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkExternalMemoryImageCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkImageDrmFormatModifierListCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
-                delete reinterpret_cast<safe_VkImageFormatListCreateInfoKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkImageStencilUsageCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
-                delete reinterpret_cast<safe_VkImageSwapchainCreateInfoKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
-                delete reinterpret_cast<safe_VkImageViewASTCDecodeModeEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
-                delete reinterpret_cast<safe_VkImageViewUsageCreateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
-                delete reinterpret_cast<safe_VkSamplerYcbcrConversionInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkShaderModuleValidationCacheCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineVertexInputDivisorStateCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
-                delete reinterpret_cast<safe_VkPipelineTessellationDomainOriginStateCreateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineViewportShadingRateImageStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineViewportWScalingStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineRasterizationConservativeStateCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
-                delete reinterpret_cast<safe_VkPipelineRasterizationStateRasterizationOrderAMD *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineCoverageModulationStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineCoverageReductionStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineCoverageToColorStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineSampleLocationsStateCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineCreationFeedbackCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkPipelineDiscardRectangleStateCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
-                delete reinterpret_cast<safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkSamplerReductionModeCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
-                delete reinterpret_cast<safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
-                delete reinterpret_cast<safe_VkWriteDescriptorSetInlineUniformBlockEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR:
-                delete reinterpret_cast<safe_VkFramebufferAttachmentsCreateInfoKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
-                delete reinterpret_cast<safe_VkRenderPassInputAttachmentAspectCreateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
-                delete reinterpret_cast<safe_VkRenderPassMultiviewCreateInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
-                delete reinterpret_cast<safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
-                delete reinterpret_cast<safe_VkDeviceGroupCommandBufferBeginInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
-                delete reinterpret_cast<safe_VkSampleLocationsInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
-                delete reinterpret_cast<safe_VkDeviceGroupRenderPassBeginInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR:
-                delete reinterpret_cast<safe_VkRenderPassAttachmentBeginInfoKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
-                delete reinterpret_cast<safe_VkRenderPassSampleLocationsBeginInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
-                delete reinterpret_cast<safe_VkBindBufferMemoryDeviceGroupInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
-                delete reinterpret_cast<safe_VkBindImageMemoryDeviceGroupInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
-                delete reinterpret_cast<safe_VkBindImageMemorySwapchainInfoKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
-                delete reinterpret_cast<safe_VkBindImagePlaneMemoryInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
-                delete reinterpret_cast<safe_VkImagePlaneMemoryRequirementsInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
-                delete reinterpret_cast<safe_VkMemoryDedicatedRequirements *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceDriverPropertiesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDeviceFloatControlsPropertiesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceIDProperties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMaintenance3Properties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMeshShaderPropertiesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMultiviewProperties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDevicePCIBusInfoPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
-                delete reinterpret_cast<safe_VkPhysicalDevicePointClippingProperties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceProtectedMemoryProperties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
-                delete reinterpret_cast<safe_VkPhysicalDevicePushDescriptorPropertiesKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceRayTracingPropertiesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceSampleLocationsPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderCorePropertiesAMD *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
-                delete reinterpret_cast<safe_VkPhysicalDeviceShadingRateImagePropertiesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
-                delete reinterpret_cast<safe_VkPhysicalDeviceSubgroupProperties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
-                delete reinterpret_cast<safe_VkDrmFormatModifierPropertiesListEXT *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
-                delete reinterpret_cast<safe_VkAndroidHardwareBufferUsageANDROID *>(header);
-                break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
-            case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
-                delete reinterpret_cast<safe_VkExternalImageFormatProperties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkFilterCubicImageViewImageFormatPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
-                delete reinterpret_cast<safe_VkSamplerYcbcrConversionImageFormatProperties *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
-                delete reinterpret_cast<safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
-                delete reinterpret_cast<safe_VkPhysicalDeviceExternalImageFormatInfo *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceImageViewImageFormatInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
-                delete reinterpret_cast<safe_VkQueueFamilyCheckpointPropertiesNV *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
-                delete reinterpret_cast<safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
-                delete reinterpret_cast<safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
-                delete reinterpret_cast<safe_VkDeviceGroupSwapchainCreateInfoKHR *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
-                delete reinterpret_cast<safe_VkSurfaceFullScreenExclusiveInfoEXT *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
-                delete reinterpret_cast<safe_VkSurfaceFullScreenExclusiveWin32InfoEXT *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
-                delete reinterpret_cast<safe_VkSwapchainCounterCreateInfoEXT *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
-                delete reinterpret_cast<safe_VkSwapchainDisplayNativeHdrCreateInfoAMD *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
-                delete reinterpret_cast<safe_VkDeviceGroupPresentInfoKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
-                delete reinterpret_cast<safe_VkDisplayPresentInfoKHR *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_GGP 
-            case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
-                delete reinterpret_cast<safe_VkPresentFrameTokenGGP *>(header);
-                break;
-#endif // VK_USE_PLATFORM_GGP 
-
-            case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
-                delete reinterpret_cast<safe_VkPresentRegionsKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
-                delete reinterpret_cast<safe_VkPresentTimesInfoGOOGLE *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR:
-                delete reinterpret_cast<safe_VkSubpassDescriptionDepthStencilResolveKHR *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
-                delete reinterpret_cast<safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
-                break;
-
-            case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
-                delete reinterpret_cast<safe_VkSharedPresentSurfaceCapabilitiesKHR *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_WIN32_KHR 
-            case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
-                delete reinterpret_cast<safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
-                break;
-#endif // VK_USE_PLATFORM_WIN32_KHR 
-
-            case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
-                delete reinterpret_cast<safe_VkSurfaceProtectedCapabilitiesKHR *>(header);
-                break;
-
-#ifdef VK_USE_PLATFORM_ANDROID_KHR 
-            case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
-                delete reinterpret_cast<safe_VkAndroidHardwareBufferFormatPropertiesANDROID *>(header);
-                break;
-#endif // VK_USE_PLATFORM_ANDROID_KHR 
-
-            default:
-                assert(0);
-        }
-    }
 }
 
 
@@ -2089,7 +168,6 @@ VkResult DispatchCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
                                                                                           pCreateInfos, pAllocator, pPipelines);
     safe_VkComputePipelineCreateInfo *local_pCreateInfos = NULL;
     if (pCreateInfos) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_pCreateInfos = new safe_VkComputePipelineCreateInfo[createInfoCount];
         for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
             local_pCreateInfos[idx0].initialize(&pCreateInfos[idx0]);
@@ -2105,7 +183,6 @@ VkResult DispatchCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
         }
     }
     if (pipelineCache) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipelineCache = layer_data->Unwrap(pipelineCache);
     }
 
@@ -2113,7 +190,6 @@ VkResult DispatchCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
                                                                                local_pCreateInfos->ptr(), pAllocator, pPipelines);
     delete[] local_pCreateInfos;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < createInfoCount; ++i) {
             if (pPipelines[i] != VK_NULL_HANDLE) {
                 pPipelines[i] = layer_data->WrapNew(pPipelines[i]);
@@ -2132,7 +208,7 @@ VkResult DispatchCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
     safe_VkGraphicsPipelineCreateInfo *local_pCreateInfos = nullptr;
     if (pCreateInfos) {
         local_pCreateInfos = new safe_VkGraphicsPipelineCreateInfo[createInfoCount];
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
             bool uses_color_attachment = false;
             bool uses_depthstencil_attachment = false;
@@ -2168,7 +244,6 @@ VkResult DispatchCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
         }
     }
     if (pipelineCache) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipelineCache = layer_data->Unwrap(pipelineCache);
     }
 
@@ -2176,7 +251,6 @@ VkResult DispatchCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
                                                                                 local_pCreateInfos->ptr(), pAllocator, pPipelines);
     delete[] local_pCreateInfos;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < createInfoCount; ++i) {
             if (pPipelines[i] != VK_NULL_HANDLE) {
                 pPipelines[i] = layer_data->WrapNew(pPipelines[i]);
@@ -2211,7 +285,7 @@ VkResult DispatchCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo
     VkResult result = layer_data->device_dispatch_table.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
     if (!wrap_handles) return result;
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         UpdateCreateRenderPassState(layer_data, pCreateInfo, *pRenderPass);
         *pRenderPass = layer_data->WrapNew(*pRenderPass);
     }
@@ -2224,7 +298,7 @@ VkResult DispatchCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateI
     VkResult result = layer_data->device_dispatch_table.CreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
     if (!wrap_handles) return result;
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         UpdateCreateRenderPassState(layer_data, pCreateInfo, *pRenderPass);
         *pRenderPass = layer_data->WrapNew(*pRenderPass);
     }
@@ -2234,14 +308,18 @@ VkResult DispatchCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateI
 void DispatchDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t renderPass_id = reinterpret_cast<uint64_t &>(renderPass);
-    renderPass = (VkRenderPass)unique_id_mapping[renderPass_id];
-    unique_id_mapping.erase(renderPass_id);
-    lock.unlock();
+
+    auto iter = unique_id_mapping.pop(renderPass_id);
+    if (iter != unique_id_mapping.end()) {
+        renderPass = (VkRenderPass)iter->second;
+    } else {
+        renderPass = (VkRenderPass)0;
+    }
+
     layer_data->device_dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
 
-    lock.lock();
+    write_dispatch_lock_guard_t lock(dispatch_lock);
     layer_data->renderpasses_states.erase(renderPass);
 }
 
@@ -2251,7 +329,6 @@ VkResult DispatchCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfo
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
     safe_VkSwapchainCreateInfoKHR *local_pCreateInfo = NULL;
     if (pCreateInfo) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_pCreateInfo = new safe_VkSwapchainCreateInfoKHR(pCreateInfo);
         local_pCreateInfo->oldSwapchain = layer_data->Unwrap(pCreateInfo->oldSwapchain);
         // Surface is instance-level object
@@ -2262,7 +339,6 @@ VkResult DispatchCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfo
     delete local_pCreateInfo;
 
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSwapchain = layer_data->WrapNew(*pSwapchain);
     }
     return result;
@@ -2276,7 +352,6 @@ VkResult DispatchCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCo
                                                                            pSwapchains);
     safe_VkSwapchainCreateInfoKHR *local_pCreateInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfos) {
             local_pCreateInfos = new safe_VkSwapchainCreateInfoKHR[swapchainCount];
             for (uint32_t i = 0; i < swapchainCount; ++i) {
@@ -2295,7 +370,6 @@ VkResult DispatchCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCo
                                                                                   pAllocator, pSwapchains);
     delete[] local_pCreateInfos;
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < swapchainCount; i++) {
             pSwapchains[i] = layer_data->WrapNew(pSwapchains[i]);
         }
@@ -2310,14 +384,13 @@ VkResult DispatchGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain
         return layer_data->device_dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
     VkSwapchainKHR wrapped_swapchain_handle = swapchain;
     if (VK_NULL_HANDLE != swapchain) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result =
         layer_data->device_dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
     if ((VK_SUCCESS == result) || (VK_INCOMPLETE == result)) {
         if ((*pSwapchainImageCount > 0) && pSwapchainImages) {
-            std::lock_guard<std::mutex> lock(dispatch_lock);
+            write_dispatch_lock_guard_t lock(dispatch_lock);
             auto &wrapped_swapchain_image_handles = layer_data->swapchain_wrapped_image_handle_map[wrapped_swapchain_handle];
             for (uint32_t i = static_cast<uint32_t>(wrapped_swapchain_image_handles.size()); i < *pSwapchainImageCount; i++) {
                 wrapped_swapchain_image_handles.emplace_back(layer_data->WrapNew(pSwapchainImages[i]));
@@ -2333,18 +406,24 @@ VkResult DispatchGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain
 void DispatchDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
 
     auto &image_array = layer_data->swapchain_wrapped_image_handle_map[swapchain];
     for (auto &image_handle : image_array) {
         unique_id_mapping.erase(HandleToUint64(image_handle));
     }
     layer_data->swapchain_wrapped_image_handle_map.erase(swapchain);
+    lock.unlock();
 
     uint64_t swapchain_id = HandleToUint64(swapchain);
-    swapchain = (VkSwapchainKHR)unique_id_mapping[swapchain_id];
-    unique_id_mapping.erase(swapchain_id);
-    lock.unlock();
+
+    auto iter = unique_id_mapping.pop(swapchain_id);
+    if (iter != unique_id_mapping.end()) {
+        swapchain = (VkSwapchainKHR)iter->second;
+    } else {
+        swapchain = (VkSwapchainKHR)0;
+    }
+
     layer_data->device_dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
 }
 
@@ -2353,7 +432,6 @@ VkResult DispatchQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresent
     if (!wrap_handles) return layer_data->device_dispatch_table.QueuePresentKHR(queue, pPresentInfo);
     safe_VkPresentInfoKHR *local_pPresentInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pPresentInfo) {
             local_pPresentInfo = new safe_VkPresentInfoKHR(pPresentInfo);
             if (local_pPresentInfo->pWaitSemaphores) {
@@ -2384,18 +462,24 @@ VkResult DispatchQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresent
 void DispatchDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
 
     // remove references to implicitly freed descriptor sets
     for(auto descriptor_set : layer_data->pool_descriptor_sets_map[descriptorPool]) {
         unique_id_mapping.erase(reinterpret_cast<uint64_t &>(descriptor_set));
     }
     layer_data->pool_descriptor_sets_map.erase(descriptorPool);
+    lock.unlock();
 
     uint64_t descriptorPool_id = reinterpret_cast<uint64_t &>(descriptorPool);
-    descriptorPool = (VkDescriptorPool)unique_id_mapping[descriptorPool_id];
-    unique_id_mapping.erase(descriptorPool_id);
-    lock.unlock();
+
+    auto iter = unique_id_mapping.pop(descriptorPool_id);
+    if (iter != unique_id_mapping.end()) {
+        descriptorPool = (VkDescriptorPool)iter->second;
+    } else {
+        descriptorPool = (VkDescriptorPool)0;
+    }
+
     layer_data->device_dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator);
 }
 
@@ -2404,12 +488,11 @@ VkResult DispatchResetDescriptorPool(VkDevice device, VkDescriptorPool descripto
     if (!wrap_handles) return layer_data->device_dispatch_table.ResetDescriptorPool(device, descriptorPool, flags);
     VkDescriptorPool local_descriptor_pool = VK_NULL_HANDLE;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_descriptor_pool = layer_data->Unwrap(descriptorPool);
     }
     VkResult result = layer_data->device_dispatch_table.ResetDescriptorPool(device, local_descriptor_pool, flags);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         // remove references to implicitly freed descriptor sets
         for(auto descriptor_set : layer_data->pool_descriptor_sets_map[descriptorPool]) {
             unique_id_mapping.erase(reinterpret_cast<uint64_t &>(descriptor_set));
@@ -2426,7 +509,6 @@ VkResult DispatchAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAl
     if (!wrap_handles) return layer_data->device_dispatch_table.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
     safe_VkDescriptorSetAllocateInfo *local_pAllocateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pAllocateInfo) {
             local_pAllocateInfo = new safe_VkDescriptorSetAllocateInfo(pAllocateInfo);
             if (pAllocateInfo->descriptorPool) {
@@ -2445,7 +527,7 @@ VkResult DispatchAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAl
         delete local_pAllocateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         auto &pool_descriptor_sets = layer_data->pool_descriptor_sets_map[pAllocateInfo->descriptorPool];
         for (uint32_t index0 = 0; index0 < pAllocateInfo->descriptorSetCount; index0++) {
             pDescriptorSets[index0] = layer_data->WrapNew(pDescriptorSets[index0]);
@@ -2463,7 +545,6 @@ VkResult DispatchFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptor
     VkDescriptorSet *local_pDescriptorSets = NULL;
     VkDescriptorPool local_descriptor_pool = VK_NULL_HANDLE;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_descriptor_pool = layer_data->Unwrap(descriptorPool);
         if (pDescriptorSets) {
             local_pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
@@ -2476,7 +557,7 @@ VkResult DispatchFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptor
                                                                            (const VkDescriptorSet *)local_pDescriptorSets);
     if (local_pDescriptorSets) delete[] local_pDescriptorSets;
     if ((VK_SUCCESS == result) && (pDescriptorSets)) {
-        std::unique_lock<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         auto &pool_descriptor_sets = layer_data->pool_descriptor_sets_map[descriptorPool];
         for (uint32_t index0 = 0; index0 < descriptorSetCount; index0++) {
             VkDescriptorSet handle = pDescriptorSets[index0];
@@ -2498,7 +579,6 @@ VkResult DispatchCreateDescriptorUpdateTemplate(VkDevice device, const VkDescrip
                                                                                 pDescriptorUpdateTemplate);
     safe_VkDescriptorUpdateTemplateCreateInfo *local_create_info = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo);
             if (pCreateInfo->descriptorSetLayout) {
@@ -2512,7 +592,7 @@ VkResult DispatchCreateDescriptorUpdateTemplate(VkDevice device, const VkDescrip
     VkResult result = layer_data->device_dispatch_table.CreateDescriptorUpdateTemplate(device, local_create_info->ptr(), pAllocator,
                                                                                        pDescriptorUpdateTemplate);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         *pDescriptorUpdateTemplate = layer_data->WrapNew(*pDescriptorUpdateTemplate);
 
         // Shadow template createInfo for later updates
@@ -2532,7 +612,6 @@ VkResult DispatchCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDesc
                                                                                    pDescriptorUpdateTemplate);
     safe_VkDescriptorUpdateTemplateCreateInfo *local_create_info = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo);
             if (pCreateInfo->descriptorSetLayout) {
@@ -2546,7 +625,7 @@ VkResult DispatchCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDesc
     VkResult result = layer_data->device_dispatch_table.CreateDescriptorUpdateTemplateKHR(device, local_create_info->ptr(), pAllocator,
                                                                                           pDescriptorUpdateTemplate);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         *pDescriptorUpdateTemplate = layer_data->WrapNew(*pDescriptorUpdateTemplate);
 
         // Shadow template createInfo for later updates
@@ -2562,12 +641,18 @@ void DispatchDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdate
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles)
         return layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
     uint64_t descriptor_update_template_id = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     layer_data->desc_template_createinfo_map.erase(descriptor_update_template_id);
-    descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[descriptor_update_template_id];
-    unique_id_mapping.erase(descriptor_update_template_id);
     lock.unlock();
+
+    auto iter = unique_id_mapping.pop(descriptor_update_template_id);
+    if (iter != unique_id_mapping.end()) {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)iter->second;
+    } else {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)0;
+    }
+
     layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
 }
 
@@ -2577,12 +662,18 @@ void DispatchDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpd
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles)
         return layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
     uint64_t descriptor_update_template_id = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     layer_data->desc_template_createinfo_map.erase(descriptor_update_template_id);
-    descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[descriptor_update_template_id];
-    unique_id_mapping.erase(descriptor_update_template_id);
     lock.unlock();
+
+    auto iter = unique_id_mapping.pop(descriptor_update_template_id);
+    if (iter != unique_id_mapping.end()) {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)iter->second;
+    } else {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)0;
+    }
+
     layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
 }
 
@@ -2692,12 +783,13 @@ void DispatchUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet de
         return layer_data->device_dispatch_table.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate,
                                                                                  pData);
     uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
+    void *unwrapped_buffer = nullptr;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         descriptorSet = layer_data->Unwrap(descriptorSet);
-        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[template_handle];
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)layer_data->Unwrap(descriptorUpdateTemplate);
+        unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
     }
-    void *unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
     layer_data->device_dispatch_table.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, unwrapped_buffer);
     free(unwrapped_buffer);
 }
@@ -2711,9 +803,9 @@ void DispatchUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet
     uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     void *unwrapped_buffer = nullptr;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         descriptorSet = layer_data->Unwrap(descriptorSet);
-        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[template_handle];
+        descriptorUpdateTemplate = layer_data->Unwrap(descriptorUpdateTemplate);
         unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
     }
     layer_data->device_dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, unwrapped_buffer);
@@ -2730,7 +822,7 @@ void DispatchCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
     uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     void *unwrapped_buffer = nullptr;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         descriptorUpdateTemplate = layer_data->Unwrap(descriptorUpdateTemplate);
         layout = layer_data->Unwrap(layout);
         unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
@@ -2747,7 +839,6 @@ VkResult DispatchGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical
         layer_data->instance_dispatch_table.GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].display = layer_data->MaybeWrapDisplay(pProperties[idx0].display, layer_data);
         }
@@ -2762,7 +853,6 @@ VkResult DispatchGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physica
         layer_data->instance_dispatch_table.GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].displayProperties.display =
                 layer_data->MaybeWrapDisplay(pProperties[idx0].displayProperties.display, layer_data);
@@ -2778,7 +868,6 @@ VkResult DispatchGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice phy
         layer_data->instance_dispatch_table.GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             VkDisplayKHR &opt_display = pProperties[idx0].currentDisplay;
             if (opt_display) opt_display = layer_data->MaybeWrapDisplay(opt_display, layer_data);
@@ -2794,7 +883,6 @@ VkResult DispatchGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice ph
                                                                                                       pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             VkDisplayKHR &opt_display = pProperties[idx0].displayPlaneProperties.currentDisplay;
             if (opt_display) opt_display = layer_data->MaybeWrapDisplay(opt_display, layer_data);
@@ -2810,7 +898,6 @@ VkResult DispatchGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDe
                                                                                               pDisplayCount, pDisplays);
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pDisplays) {
     if (!wrap_handles) return result;
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < *pDisplayCount; ++i) {
             if (pDisplays[i]) pDisplays[i] = layer_data->MaybeWrapDisplay(pDisplays[i], layer_data);
         }
@@ -2825,13 +912,11 @@ VkResult DispatchGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, Vk
         return layer_data->instance_dispatch_table.GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount,
                                                                                pProperties);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
 
     VkResult result = layer_data->instance_dispatch_table.GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].displayMode = layer_data->WrapNew(pProperties[idx0].displayMode);
         }
@@ -2846,14 +931,12 @@ VkResult DispatchGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, V
         return layer_data->instance_dispatch_table.GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount,
                                                                                 pProperties);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
 
     VkResult result =
         layer_data->instance_dispatch_table.GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].displayModeProperties.displayMode = layer_data->WrapNew(pProperties[idx0].displayModeProperties.displayMode);
         }
@@ -2866,7 +949,6 @@ VkResult DispatchDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarker
     if (!wrap_handles) return layer_data->device_dispatch_table.DebugMarkerSetObjectTagEXT(device, pTagInfo);
     safe_VkDebugMarkerObjectTagInfoEXT local_tag_info(pTagInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_tag_info.object));
         if (it != unique_id_mapping.end()) {
             local_tag_info.object = it->second;
@@ -2882,7 +964,6 @@ VkResult DispatchDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarke
     if (!wrap_handles) return layer_data->device_dispatch_table.DebugMarkerSetObjectNameEXT(device, pNameInfo);
     safe_VkDebugMarkerObjectNameInfoEXT local_name_info(pNameInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_name_info.object));
         if (it != unique_id_mapping.end()) {
             local_name_info.object = it->second;
@@ -2899,7 +980,6 @@ VkResult DispatchSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsOb
     if (!wrap_handles) return layer_data->device_dispatch_table.SetDebugUtilsObjectTagEXT(device, pTagInfo);
     safe_VkDebugUtilsObjectTagInfoEXT local_tag_info(pTagInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_tag_info.objectHandle));
         if (it != unique_id_mapping.end()) {
             local_tag_info.objectHandle = it->second;
@@ -2915,7 +995,6 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
     if (!wrap_handles) return layer_data->device_dispatch_table.SetDebugUtilsObjectNameEXT(device, pNameInfo);
     safe_VkDebugUtilsObjectNameInfoEXT local_name_info(pNameInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_name_info.objectHandle));
         if (it != unique_id_mapping.end()) {
             local_name_info.objectHandle = it->second;
@@ -3059,12 +1138,11 @@ VkResult DispatchQueueSubmit(
     if (!wrap_handles) return layer_data->device_dispatch_table.QueueSubmit(queue, submitCount, pSubmits, fence);
     safe_VkSubmitInfo *local_pSubmits = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pSubmits) {
             local_pSubmits = new safe_VkSubmitInfo[submitCount];
             for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
                 local_pSubmits[index0].initialize(&pSubmits[index0]);
-                local_pSubmits[index0].pNext = CreateUnwrappedExtensionStructs(layer_data, local_pSubmits[index0].pNext);
+                WrapPnextChainHandles(layer_data, local_pSubmits[index0].pNext);
                 if (local_pSubmits[index0].pWaitSemaphores) {
                     for (uint32_t index1 = 0; index1 < local_pSubmits[index0].waitSemaphoreCount; ++index1) {
                         local_pSubmits[index0].pWaitSemaphores[index1] = layer_data->Unwrap(local_pSubmits[index0].pWaitSemaphores[index1]);
@@ -3081,9 +1159,6 @@ VkResult DispatchQueueSubmit(
     }
     VkResult result = layer_data->device_dispatch_table.QueueSubmit(queue, submitCount, (const VkSubmitInfo*)local_pSubmits, fence);
     if (local_pSubmits) {
-        for (uint32_t index0 = 0; index0 < submitCount; ++index0) {
-            FreeUnwrappedExtensionStructs(const_cast<void *>(local_pSubmits[index0].pNext));
-        }
         delete[] local_pSubmits;
     }
     return result;
@@ -3117,19 +1192,16 @@ VkResult DispatchAllocateMemory(
     if (!wrap_handles) return layer_data->device_dispatch_table.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
     safe_VkMemoryAllocateInfo *local_pAllocateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pAllocateInfo) {
             local_pAllocateInfo = new safe_VkMemoryAllocateInfo(pAllocateInfo);
-            local_pAllocateInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pAllocateInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pAllocateInfo->pNext);
         }
     }
     VkResult result = layer_data->device_dispatch_table.AllocateMemory(device, (const VkMemoryAllocateInfo*)local_pAllocateInfo, pAllocator, pMemory);
     if (local_pAllocateInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pAllocateInfo->pNext));
         delete local_pAllocateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pMemory = layer_data->WrapNew(*pMemory);
     }
     return result;
@@ -3142,11 +1214,13 @@ void DispatchFreeMemory(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.FreeMemory(device, memory, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t memory_id = reinterpret_cast<uint64_t &>(memory);
-    memory = (VkDeviceMemory)unique_id_mapping[memory_id];
-    unique_id_mapping.erase(memory_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(memory_id);
+    if (iter != unique_id_mapping.end()) {
+        memory = (VkDeviceMemory)iter->second;
+    } else {
+        memory = (VkDeviceMemory)0;
+    }
     layer_data->device_dispatch_table.FreeMemory(device, memory, pAllocator);
 
 }
@@ -3162,7 +1236,6 @@ VkResult DispatchMapMemory(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.MapMemory(device, memory, offset, size, flags, ppData);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         memory = layer_data->Unwrap(memory);
     }
     VkResult result = layer_data->device_dispatch_table.MapMemory(device, memory, offset, size, flags, ppData);
@@ -3177,7 +1250,6 @@ void DispatchUnmapMemory(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.UnmapMemory(device, memory);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         memory = layer_data->Unwrap(memory);
     }
     layer_data->device_dispatch_table.UnmapMemory(device, memory);
@@ -3193,7 +1265,6 @@ VkResult DispatchFlushMappedMemoryRanges(
     if (!wrap_handles) return layer_data->device_dispatch_table.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
     safe_VkMappedMemoryRange *local_pMemoryRanges = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pMemoryRanges) {
             local_pMemoryRanges = new safe_VkMappedMemoryRange[memoryRangeCount];
             for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
@@ -3220,7 +1291,6 @@ VkResult DispatchInvalidateMappedMemoryRanges(
     if (!wrap_handles) return layer_data->device_dispatch_table.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
     safe_VkMappedMemoryRange *local_pMemoryRanges = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pMemoryRanges) {
             local_pMemoryRanges = new safe_VkMappedMemoryRange[memoryRangeCount];
             for (uint32_t index0 = 0; index0 < memoryRangeCount; ++index0) {
@@ -3246,7 +1316,6 @@ void DispatchGetDeviceMemoryCommitment(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         memory = layer_data->Unwrap(memory);
     }
     layer_data->device_dispatch_table.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
@@ -3262,7 +1331,6 @@ VkResult DispatchBindBufferMemory(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.BindBufferMemory(device, buffer, memory, memoryOffset);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
         memory = layer_data->Unwrap(memory);
     }
@@ -3280,7 +1348,6 @@ VkResult DispatchBindImageMemory(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.BindImageMemory(device, image, memory, memoryOffset);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         image = layer_data->Unwrap(image);
         memory = layer_data->Unwrap(memory);
     }
@@ -3297,7 +1364,6 @@ void DispatchGetBufferMemoryRequirements(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
     }
     layer_data->device_dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
@@ -3312,7 +1378,6 @@ void DispatchGetImageMemoryRequirements(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         image = layer_data->Unwrap(image);
     }
     layer_data->device_dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements);
@@ -3328,7 +1393,6 @@ void DispatchGetImageSparseMemoryRequirements(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         image = layer_data->Unwrap(image);
     }
     layer_data->device_dispatch_table.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
@@ -3360,7 +1424,6 @@ VkResult DispatchQueueBindSparse(
     if (!wrap_handles) return layer_data->device_dispatch_table.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
     safe_VkBindSparseInfo *local_pBindInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBindInfo) {
             local_pBindInfo = new safe_VkBindSparseInfo[bindInfoCount];
             for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
@@ -3438,7 +1501,6 @@ VkResult DispatchCreateFence(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence);
     VkResult result = layer_data->device_dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pFence = layer_data->WrapNew(*pFence);
     }
     return result;
@@ -3451,11 +1513,13 @@ void DispatchDestroyFence(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyFence(device, fence, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t fence_id = reinterpret_cast<uint64_t &>(fence);
-    fence = (VkFence)unique_id_mapping[fence_id];
-    unique_id_mapping.erase(fence_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(fence_id);
+    if (iter != unique_id_mapping.end()) {
+        fence = (VkFence)iter->second;
+    } else {
+        fence = (VkFence)0;
+    }
     layer_data->device_dispatch_table.DestroyFence(device, fence, pAllocator);
 
 }
@@ -3469,7 +1533,6 @@ VkResult DispatchResetFences(
     if (!wrap_handles) return layer_data->device_dispatch_table.ResetFences(device, fenceCount, pFences);
     VkFence *local_pFences = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pFences) {
             local_pFences = new VkFence[fenceCount];
             for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
@@ -3490,7 +1553,6 @@ VkResult DispatchGetFenceStatus(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetFenceStatus(device, fence);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         fence = layer_data->Unwrap(fence);
     }
     VkResult result = layer_data->device_dispatch_table.GetFenceStatus(device, fence);
@@ -3509,7 +1571,6 @@ VkResult DispatchWaitForFences(
     if (!wrap_handles) return layer_data->device_dispatch_table.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
     VkFence *local_pFences = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pFences) {
             local_pFences = new VkFence[fenceCount];
             for (uint32_t index0 = 0; index0 < fenceCount; ++index0) {
@@ -3533,7 +1594,6 @@ VkResult DispatchCreateSemaphore(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
     VkResult result = layer_data->device_dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSemaphore = layer_data->WrapNew(*pSemaphore);
     }
     return result;
@@ -3546,11 +1606,13 @@ void DispatchDestroySemaphore(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroySemaphore(device, semaphore, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t semaphore_id = reinterpret_cast<uint64_t &>(semaphore);
-    semaphore = (VkSemaphore)unique_id_mapping[semaphore_id];
-    unique_id_mapping.erase(semaphore_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(semaphore_id);
+    if (iter != unique_id_mapping.end()) {
+        semaphore = (VkSemaphore)iter->second;
+    } else {
+        semaphore = (VkSemaphore)0;
+    }
     layer_data->device_dispatch_table.DestroySemaphore(device, semaphore, pAllocator);
 
 }
@@ -3565,7 +1627,6 @@ VkResult DispatchCreateEvent(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
     VkResult result = layer_data->device_dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pEvent = layer_data->WrapNew(*pEvent);
     }
     return result;
@@ -3578,11 +1639,13 @@ void DispatchDestroyEvent(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyEvent(device, event, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t event_id = reinterpret_cast<uint64_t &>(event);
-    event = (VkEvent)unique_id_mapping[event_id];
-    unique_id_mapping.erase(event_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(event_id);
+    if (iter != unique_id_mapping.end()) {
+        event = (VkEvent)iter->second;
+    } else {
+        event = (VkEvent)0;
+    }
     layer_data->device_dispatch_table.DestroyEvent(device, event, pAllocator);
 
 }
@@ -3594,7 +1657,6 @@ VkResult DispatchGetEventStatus(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetEventStatus(device, event);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         event = layer_data->Unwrap(event);
     }
     VkResult result = layer_data->device_dispatch_table.GetEventStatus(device, event);
@@ -3609,7 +1671,6 @@ VkResult DispatchSetEvent(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.SetEvent(device, event);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         event = layer_data->Unwrap(event);
     }
     VkResult result = layer_data->device_dispatch_table.SetEvent(device, event);
@@ -3624,7 +1685,6 @@ VkResult DispatchResetEvent(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.ResetEvent(device, event);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         event = layer_data->Unwrap(event);
     }
     VkResult result = layer_data->device_dispatch_table.ResetEvent(device, event);
@@ -3642,7 +1702,6 @@ VkResult DispatchCreateQueryPool(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
     VkResult result = layer_data->device_dispatch_table.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pQueryPool = layer_data->WrapNew(*pQueryPool);
     }
     return result;
@@ -3655,11 +1714,13 @@ void DispatchDestroyQueryPool(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyQueryPool(device, queryPool, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t queryPool_id = reinterpret_cast<uint64_t &>(queryPool);
-    queryPool = (VkQueryPool)unique_id_mapping[queryPool_id];
-    unique_id_mapping.erase(queryPool_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(queryPool_id);
+    if (iter != unique_id_mapping.end()) {
+        queryPool = (VkQueryPool)iter->second;
+    } else {
+        queryPool = (VkQueryPool)0;
+    }
     layer_data->device_dispatch_table.DestroyQueryPool(device, queryPool, pAllocator);
 
 }
@@ -3677,7 +1738,6 @@ VkResult DispatchGetQueryPoolResults(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     VkResult result = layer_data->device_dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
@@ -3695,7 +1755,6 @@ VkResult DispatchCreateBuffer(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
     VkResult result = layer_data->device_dispatch_table.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pBuffer = layer_data->WrapNew(*pBuffer);
     }
     return result;
@@ -3708,11 +1767,13 @@ void DispatchDestroyBuffer(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyBuffer(device, buffer, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t buffer_id = reinterpret_cast<uint64_t &>(buffer);
-    buffer = (VkBuffer)unique_id_mapping[buffer_id];
-    unique_id_mapping.erase(buffer_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(buffer_id);
+    if (iter != unique_id_mapping.end()) {
+        buffer = (VkBuffer)iter->second;
+    } else {
+        buffer = (VkBuffer)0;
+    }
     layer_data->device_dispatch_table.DestroyBuffer(device, buffer, pAllocator);
 
 }
@@ -3727,7 +1788,6 @@ VkResult DispatchCreateBufferView(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateBufferView(device, pCreateInfo, pAllocator, pView);
     safe_VkBufferViewCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkBufferViewCreateInfo(pCreateInfo);
             if (pCreateInfo->buffer) {
@@ -3740,7 +1800,6 @@ VkResult DispatchCreateBufferView(
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pView = layer_data->WrapNew(*pView);
     }
     return result;
@@ -3753,11 +1812,13 @@ void DispatchDestroyBufferView(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyBufferView(device, bufferView, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t bufferView_id = reinterpret_cast<uint64_t &>(bufferView);
-    bufferView = (VkBufferView)unique_id_mapping[bufferView_id];
-    unique_id_mapping.erase(bufferView_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(bufferView_id);
+    if (iter != unique_id_mapping.end()) {
+        bufferView = (VkBufferView)iter->second;
+    } else {
+        bufferView = (VkBufferView)0;
+    }
     layer_data->device_dispatch_table.DestroyBufferView(device, bufferView, pAllocator);
 
 }
@@ -3772,19 +1833,16 @@ VkResult DispatchCreateImage(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateImage(device, pCreateInfo, pAllocator, pImage);
     safe_VkImageCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkImageCreateInfo(pCreateInfo);
-            local_pCreateInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pCreateInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pCreateInfo->pNext);
         }
     }
     VkResult result = layer_data->device_dispatch_table.CreateImage(device, (const VkImageCreateInfo*)local_pCreateInfo, pAllocator, pImage);
     if (local_pCreateInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pCreateInfo->pNext));
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pImage = layer_data->WrapNew(*pImage);
     }
     return result;
@@ -3797,11 +1855,13 @@ void DispatchDestroyImage(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyImage(device, image, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t image_id = reinterpret_cast<uint64_t &>(image);
-    image = (VkImage)unique_id_mapping[image_id];
-    unique_id_mapping.erase(image_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(image_id);
+    if (iter != unique_id_mapping.end()) {
+        image = (VkImage)iter->second;
+    } else {
+        image = (VkImage)0;
+    }
     layer_data->device_dispatch_table.DestroyImage(device, image, pAllocator);
 
 }
@@ -3815,7 +1875,6 @@ void DispatchGetImageSubresourceLayout(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         image = layer_data->Unwrap(image);
     }
     layer_data->device_dispatch_table.GetImageSubresourceLayout(device, image, pSubresource, pLayout);
@@ -3832,22 +1891,19 @@ VkResult DispatchCreateImageView(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateImageView(device, pCreateInfo, pAllocator, pView);
     safe_VkImageViewCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkImageViewCreateInfo(pCreateInfo);
             if (pCreateInfo->image) {
                 local_pCreateInfo->image = layer_data->Unwrap(pCreateInfo->image);
             }
-            local_pCreateInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pCreateInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pCreateInfo->pNext);
         }
     }
     VkResult result = layer_data->device_dispatch_table.CreateImageView(device, (const VkImageViewCreateInfo*)local_pCreateInfo, pAllocator, pView);
     if (local_pCreateInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pCreateInfo->pNext));
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pView = layer_data->WrapNew(*pView);
     }
     return result;
@@ -3860,11 +1916,13 @@ void DispatchDestroyImageView(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyImageView(device, imageView, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t imageView_id = reinterpret_cast<uint64_t &>(imageView);
-    imageView = (VkImageView)unique_id_mapping[imageView_id];
-    unique_id_mapping.erase(imageView_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(imageView_id);
+    if (iter != unique_id_mapping.end()) {
+        imageView = (VkImageView)iter->second;
+    } else {
+        imageView = (VkImageView)0;
+    }
     layer_data->device_dispatch_table.DestroyImageView(device, imageView, pAllocator);
 
 }
@@ -3879,19 +1937,16 @@ VkResult DispatchCreateShaderModule(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
     safe_VkShaderModuleCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkShaderModuleCreateInfo(pCreateInfo);
-            local_pCreateInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pCreateInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pCreateInfo->pNext);
         }
     }
     VkResult result = layer_data->device_dispatch_table.CreateShaderModule(device, (const VkShaderModuleCreateInfo*)local_pCreateInfo, pAllocator, pShaderModule);
     if (local_pCreateInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pCreateInfo->pNext));
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pShaderModule = layer_data->WrapNew(*pShaderModule);
     }
     return result;
@@ -3904,11 +1959,13 @@ void DispatchDestroyShaderModule(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyShaderModule(device, shaderModule, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t shaderModule_id = reinterpret_cast<uint64_t &>(shaderModule);
-    shaderModule = (VkShaderModule)unique_id_mapping[shaderModule_id];
-    unique_id_mapping.erase(shaderModule_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(shaderModule_id);
+    if (iter != unique_id_mapping.end()) {
+        shaderModule = (VkShaderModule)iter->second;
+    } else {
+        shaderModule = (VkShaderModule)0;
+    }
     layer_data->device_dispatch_table.DestroyShaderModule(device, shaderModule, pAllocator);
 
 }
@@ -3923,7 +1980,6 @@ VkResult DispatchCreatePipelineCache(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
     VkResult result = layer_data->device_dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pPipelineCache = layer_data->WrapNew(*pPipelineCache);
     }
     return result;
@@ -3936,11 +1992,13 @@ void DispatchDestroyPipelineCache(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t pipelineCache_id = reinterpret_cast<uint64_t &>(pipelineCache);
-    pipelineCache = (VkPipelineCache)unique_id_mapping[pipelineCache_id];
-    unique_id_mapping.erase(pipelineCache_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(pipelineCache_id);
+    if (iter != unique_id_mapping.end()) {
+        pipelineCache = (VkPipelineCache)iter->second;
+    } else {
+        pipelineCache = (VkPipelineCache)0;
+    }
     layer_data->device_dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator);
 
 }
@@ -3954,7 +2012,6 @@ VkResult DispatchGetPipelineCacheData(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipelineCache = layer_data->Unwrap(pipelineCache);
     }
     VkResult result = layer_data->device_dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
@@ -3972,7 +2029,6 @@ VkResult DispatchMergePipelineCaches(
     if (!wrap_handles) return layer_data->device_dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
     VkPipelineCache *local_pSrcCaches = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         dstCache = layer_data->Unwrap(dstCache);
         if (pSrcCaches) {
             local_pSrcCaches = new VkPipelineCache[srcCacheCount];
@@ -3998,11 +2054,13 @@ void DispatchDestroyPipeline(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyPipeline(device, pipeline, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t pipeline_id = reinterpret_cast<uint64_t &>(pipeline);
-    pipeline = (VkPipeline)unique_id_mapping[pipeline_id];
-    unique_id_mapping.erase(pipeline_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(pipeline_id);
+    if (iter != unique_id_mapping.end()) {
+        pipeline = (VkPipeline)iter->second;
+    } else {
+        pipeline = (VkPipeline)0;
+    }
     layer_data->device_dispatch_table.DestroyPipeline(device, pipeline, pAllocator);
 
 }
@@ -4017,7 +2075,6 @@ VkResult DispatchCreatePipelineLayout(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
     safe_VkPipelineLayoutCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkPipelineLayoutCreateInfo(pCreateInfo);
             if (local_pCreateInfo->pSetLayouts) {
@@ -4032,7 +2089,6 @@ VkResult DispatchCreatePipelineLayout(
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pPipelineLayout = layer_data->WrapNew(*pPipelineLayout);
     }
     return result;
@@ -4045,11 +2101,13 @@ void DispatchDestroyPipelineLayout(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t pipelineLayout_id = reinterpret_cast<uint64_t &>(pipelineLayout);
-    pipelineLayout = (VkPipelineLayout)unique_id_mapping[pipelineLayout_id];
-    unique_id_mapping.erase(pipelineLayout_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(pipelineLayout_id);
+    if (iter != unique_id_mapping.end()) {
+        pipelineLayout = (VkPipelineLayout)iter->second;
+    } else {
+        pipelineLayout = (VkPipelineLayout)0;
+    }
     layer_data->device_dispatch_table.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
 
 }
@@ -4064,19 +2122,16 @@ VkResult DispatchCreateSampler(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateSampler(device, pCreateInfo, pAllocator, pSampler);
     safe_VkSamplerCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkSamplerCreateInfo(pCreateInfo);
-            local_pCreateInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pCreateInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pCreateInfo->pNext);
         }
     }
     VkResult result = layer_data->device_dispatch_table.CreateSampler(device, (const VkSamplerCreateInfo*)local_pCreateInfo, pAllocator, pSampler);
     if (local_pCreateInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pCreateInfo->pNext));
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSampler = layer_data->WrapNew(*pSampler);
     }
     return result;
@@ -4089,11 +2144,13 @@ void DispatchDestroySampler(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroySampler(device, sampler, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t sampler_id = reinterpret_cast<uint64_t &>(sampler);
-    sampler = (VkSampler)unique_id_mapping[sampler_id];
-    unique_id_mapping.erase(sampler_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(sampler_id);
+    if (iter != unique_id_mapping.end()) {
+        sampler = (VkSampler)iter->second;
+    } else {
+        sampler = (VkSampler)0;
+    }
     layer_data->device_dispatch_table.DestroySampler(device, sampler, pAllocator);
 
 }
@@ -4108,7 +2165,6 @@ VkResult DispatchCreateDescriptorSetLayout(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
     safe_VkDescriptorSetLayoutCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
             if (local_pCreateInfo->pBindings) {
@@ -4127,7 +2183,6 @@ VkResult DispatchCreateDescriptorSetLayout(
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSetLayout = layer_data->WrapNew(*pSetLayout);
     }
     return result;
@@ -4140,11 +2195,13 @@ void DispatchDestroyDescriptorSetLayout(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t descriptorSetLayout_id = reinterpret_cast<uint64_t &>(descriptorSetLayout);
-    descriptorSetLayout = (VkDescriptorSetLayout)unique_id_mapping[descriptorSetLayout_id];
-    unique_id_mapping.erase(descriptorSetLayout_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(descriptorSetLayout_id);
+    if (iter != unique_id_mapping.end()) {
+        descriptorSetLayout = (VkDescriptorSetLayout)iter->second;
+    } else {
+        descriptorSetLayout = (VkDescriptorSetLayout)0;
+    }
     layer_data->device_dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 
 }
@@ -4159,7 +2216,6 @@ VkResult DispatchCreateDescriptorPool(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
     VkResult result = layer_data->device_dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pDescriptorPool = layer_data->WrapNew(*pDescriptorPool);
     }
     return result;
@@ -4185,12 +2241,11 @@ void DispatchUpdateDescriptorSets(
     safe_VkWriteDescriptorSet *local_pDescriptorWrites = NULL;
     safe_VkCopyDescriptorSet *local_pDescriptorCopies = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pDescriptorWrites) {
             local_pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
             for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
                 local_pDescriptorWrites[index0].initialize(&pDescriptorWrites[index0]);
-                local_pDescriptorWrites[index0].pNext = CreateUnwrappedExtensionStructs(layer_data, local_pDescriptorWrites[index0].pNext);
+                WrapPnextChainHandles(layer_data, local_pDescriptorWrites[index0].pNext);
                 if (pDescriptorWrites[index0].dstSet) {
                     local_pDescriptorWrites[index0].dstSet = layer_data->Unwrap(pDescriptorWrites[index0].dstSet);
                 }
@@ -4233,9 +2288,6 @@ void DispatchUpdateDescriptorSets(
     }
     layer_data->device_dispatch_table.UpdateDescriptorSets(device, descriptorWriteCount, (const VkWriteDescriptorSet*)local_pDescriptorWrites, descriptorCopyCount, (const VkCopyDescriptorSet*)local_pDescriptorCopies);
     if (local_pDescriptorWrites) {
-        for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
-            FreeUnwrappedExtensionStructs(const_cast<void *>(local_pDescriptorWrites[index0].pNext));
-        }
         delete[] local_pDescriptorWrites;
     }
     if (local_pDescriptorCopies) {
@@ -4253,7 +2305,6 @@ VkResult DispatchCreateFramebuffer(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
     safe_VkFramebufferCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkFramebufferCreateInfo(pCreateInfo);
             if (pCreateInfo->renderPass) {
@@ -4271,7 +2322,6 @@ VkResult DispatchCreateFramebuffer(
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pFramebuffer = layer_data->WrapNew(*pFramebuffer);
     }
     return result;
@@ -4284,11 +2334,13 @@ void DispatchDestroyFramebuffer(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyFramebuffer(device, framebuffer, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t framebuffer_id = reinterpret_cast<uint64_t &>(framebuffer);
-    framebuffer = (VkFramebuffer)unique_id_mapping[framebuffer_id];
-    unique_id_mapping.erase(framebuffer_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(framebuffer_id);
+    if (iter != unique_id_mapping.end()) {
+        framebuffer = (VkFramebuffer)iter->second;
+    } else {
+        framebuffer = (VkFramebuffer)0;
+    }
     layer_data->device_dispatch_table.DestroyFramebuffer(device, framebuffer, pAllocator);
 
 }
@@ -4305,7 +2357,6 @@ void DispatchGetRenderAreaGranularity(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetRenderAreaGranularity(device, renderPass, pGranularity);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         renderPass = layer_data->Unwrap(renderPass);
     }
     layer_data->device_dispatch_table.GetRenderAreaGranularity(device, renderPass, pGranularity);
@@ -4322,7 +2373,6 @@ VkResult DispatchCreateCommandPool(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
     VkResult result = layer_data->device_dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pCommandPool = layer_data->WrapNew(*pCommandPool);
     }
     return result;
@@ -4335,11 +2385,13 @@ void DispatchDestroyCommandPool(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyCommandPool(device, commandPool, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t commandPool_id = reinterpret_cast<uint64_t &>(commandPool);
-    commandPool = (VkCommandPool)unique_id_mapping[commandPool_id];
-    unique_id_mapping.erase(commandPool_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(commandPool_id);
+    if (iter != unique_id_mapping.end()) {
+        commandPool = (VkCommandPool)iter->second;
+    } else {
+        commandPool = (VkCommandPool)0;
+    }
     layer_data->device_dispatch_table.DestroyCommandPool(device, commandPool, pAllocator);
 
 }
@@ -4352,7 +2404,6 @@ VkResult DispatchResetCommandPool(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.ResetCommandPool(device, commandPool, flags);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         commandPool = layer_data->Unwrap(commandPool);
     }
     VkResult result = layer_data->device_dispatch_table.ResetCommandPool(device, commandPool, flags);
@@ -4369,7 +2420,6 @@ VkResult DispatchAllocateCommandBuffers(
     if (!wrap_handles) return layer_data->device_dispatch_table.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
     safe_VkCommandBufferAllocateInfo *local_pAllocateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pAllocateInfo) {
             local_pAllocateInfo = new safe_VkCommandBufferAllocateInfo(pAllocateInfo);
             if (pAllocateInfo->commandPool) {
@@ -4393,7 +2443,6 @@ void DispatchFreeCommandBuffers(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         commandPool = layer_data->Unwrap(commandPool);
     }
     layer_data->device_dispatch_table.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
@@ -4408,7 +2457,6 @@ VkResult DispatchBeginCommandBuffer(
     if (!wrap_handles) return layer_data->device_dispatch_table.BeginCommandBuffer(commandBuffer, pBeginInfo);
     safe_VkCommandBufferBeginInfo *local_pBeginInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBeginInfo) {
             local_pBeginInfo = new safe_VkCommandBufferBeginInfo(pBeginInfo);
             if (local_pBeginInfo->pInheritanceInfo) {
@@ -4455,7 +2503,6 @@ void DispatchCmdBindPipeline(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipeline = layer_data->Unwrap(pipeline);
     }
     layer_data->device_dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
@@ -4567,7 +2614,6 @@ void DispatchCmdBindDescriptorSets(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
     VkDescriptorSet *local_pDescriptorSets = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         layout = layer_data->Unwrap(layout);
         if (pDescriptorSets) {
             local_pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
@@ -4590,7 +2636,6 @@ void DispatchCmdBindIndexBuffer(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
     }
     layer_data->device_dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
@@ -4608,7 +2653,6 @@ void DispatchCmdBindVertexBuffers(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
     VkBuffer *local_pBuffers = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBuffers) {
             local_pBuffers = new VkBuffer[bindingCount];
             for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
@@ -4656,7 +2700,6 @@ void DispatchCmdDrawIndirect(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
     }
     layer_data->device_dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
@@ -4673,7 +2716,6 @@ void DispatchCmdDrawIndexedIndirect(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
     }
     layer_data->device_dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
@@ -4699,7 +2741,6 @@ void DispatchCmdDispatchIndirect(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
     }
     layer_data->device_dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset);
@@ -4716,7 +2757,6 @@ void DispatchCmdCopyBuffer(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         srcBuffer = layer_data->Unwrap(srcBuffer);
         dstBuffer = layer_data->Unwrap(dstBuffer);
     }
@@ -4736,7 +2776,6 @@ void DispatchCmdCopyImage(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         srcImage = layer_data->Unwrap(srcImage);
         dstImage = layer_data->Unwrap(dstImage);
     }
@@ -4757,7 +2796,6 @@ void DispatchCmdBlitImage(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         srcImage = layer_data->Unwrap(srcImage);
         dstImage = layer_data->Unwrap(dstImage);
     }
@@ -4776,7 +2814,6 @@ void DispatchCmdCopyBufferToImage(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         srcBuffer = layer_data->Unwrap(srcBuffer);
         dstImage = layer_data->Unwrap(dstImage);
     }
@@ -4795,7 +2832,6 @@ void DispatchCmdCopyImageToBuffer(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         srcImage = layer_data->Unwrap(srcImage);
         dstBuffer = layer_data->Unwrap(dstBuffer);
     }
@@ -4813,7 +2849,6 @@ void DispatchCmdUpdateBuffer(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         dstBuffer = layer_data->Unwrap(dstBuffer);
     }
     layer_data->device_dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
@@ -4830,7 +2865,6 @@ void DispatchCmdFillBuffer(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         dstBuffer = layer_data->Unwrap(dstBuffer);
     }
     layer_data->device_dispatch_table.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
@@ -4848,7 +2882,6 @@ void DispatchCmdClearColorImage(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         image = layer_data->Unwrap(image);
     }
     layer_data->device_dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
@@ -4866,7 +2899,6 @@ void DispatchCmdClearDepthStencilImage(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         image = layer_data->Unwrap(image);
     }
     layer_data->device_dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
@@ -4897,7 +2929,6 @@ void DispatchCmdResolveImage(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         srcImage = layer_data->Unwrap(srcImage);
         dstImage = layer_data->Unwrap(dstImage);
     }
@@ -4913,7 +2944,6 @@ void DispatchCmdSetEvent(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         event = layer_data->Unwrap(event);
     }
     layer_data->device_dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
@@ -4928,7 +2958,6 @@ void DispatchCmdResetEvent(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdResetEvent(commandBuffer, event, stageMask);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         event = layer_data->Unwrap(event);
     }
     layer_data->device_dispatch_table.CmdResetEvent(commandBuffer, event, stageMask);
@@ -4954,7 +2983,6 @@ void DispatchCmdWaitEvents(
     safe_VkBufferMemoryBarrier *local_pBufferMemoryBarriers = NULL;
     safe_VkImageMemoryBarrier *local_pImageMemoryBarriers = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pEvents) {
             local_pEvents = new VkEvent[eventCount];
             for (uint32_t index0 = 0; index0 < eventCount; ++index0) {
@@ -5008,7 +3036,6 @@ void DispatchCmdPipelineBarrier(
     safe_VkBufferMemoryBarrier *local_pBufferMemoryBarriers = NULL;
     safe_VkImageMemoryBarrier *local_pImageMemoryBarriers = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBufferMemoryBarriers) {
             local_pBufferMemoryBarriers = new safe_VkBufferMemoryBarrier[bufferMemoryBarrierCount];
             for (uint32_t index0 = 0; index0 < bufferMemoryBarrierCount; ++index0) {
@@ -5046,7 +3073,6 @@ void DispatchCmdBeginQuery(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBeginQuery(commandBuffer, queryPool, query, flags);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     layer_data->device_dispatch_table.CmdBeginQuery(commandBuffer, queryPool, query, flags);
@@ -5061,7 +3087,6 @@ void DispatchCmdEndQuery(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdEndQuery(commandBuffer, queryPool, query);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     layer_data->device_dispatch_table.CmdEndQuery(commandBuffer, queryPool, query);
@@ -5077,7 +3102,6 @@ void DispatchCmdResetQueryPool(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     layer_data->device_dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
@@ -5093,7 +3117,6 @@ void DispatchCmdWriteTimestamp(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     layer_data->device_dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
@@ -5113,7 +3136,6 @@ void DispatchCmdCopyQueryPoolResults(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
         dstBuffer = layer_data->Unwrap(dstBuffer);
     }
@@ -5132,7 +3154,6 @@ void DispatchCmdPushConstants(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         layout = layer_data->Unwrap(layout);
     }
     layer_data->device_dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
@@ -5148,7 +3169,6 @@ void DispatchCmdBeginRenderPass(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
     safe_VkRenderPassBeginInfo *local_pRenderPassBegin = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pRenderPassBegin) {
             local_pRenderPassBegin = new safe_VkRenderPassBeginInfo(pRenderPassBegin);
             if (pRenderPassBegin->renderPass) {
@@ -5157,12 +3177,11 @@ void DispatchCmdBeginRenderPass(
             if (pRenderPassBegin->framebuffer) {
                 local_pRenderPassBegin->framebuffer = layer_data->Unwrap(pRenderPassBegin->framebuffer);
             }
-            local_pRenderPassBegin->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pRenderPassBegin->pNext);
+            WrapPnextChainHandles(layer_data, local_pRenderPassBegin->pNext);
         }
     }
     layer_data->device_dispatch_table.CmdBeginRenderPass(commandBuffer, (const VkRenderPassBeginInfo*)local_pRenderPassBegin, contents);
     if (local_pRenderPassBegin) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pRenderPassBegin->pNext));
         delete local_pRenderPassBegin;
     }
 }
@@ -5205,7 +3224,6 @@ VkResult DispatchBindBufferMemory2(
     if (!wrap_handles) return layer_data->device_dispatch_table.BindBufferMemory2(device, bindInfoCount, pBindInfos);
     safe_VkBindBufferMemoryInfo *local_pBindInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBindInfos) {
             local_pBindInfos = new safe_VkBindBufferMemoryInfo[bindInfoCount];
             for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
@@ -5235,12 +3253,11 @@ VkResult DispatchBindImageMemory2(
     if (!wrap_handles) return layer_data->device_dispatch_table.BindImageMemory2(device, bindInfoCount, pBindInfos);
     safe_VkBindImageMemoryInfo *local_pBindInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBindInfos) {
             local_pBindInfos = new safe_VkBindImageMemoryInfo[bindInfoCount];
             for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
                 local_pBindInfos[index0].initialize(&pBindInfos[index0]);
-                local_pBindInfos[index0].pNext = CreateUnwrappedExtensionStructs(layer_data, local_pBindInfos[index0].pNext);
+                WrapPnextChainHandles(layer_data, local_pBindInfos[index0].pNext);
                 if (pBindInfos[index0].image) {
                     local_pBindInfos[index0].image = layer_data->Unwrap(pBindInfos[index0].image);
                 }
@@ -5252,9 +3269,6 @@ VkResult DispatchBindImageMemory2(
     }
     VkResult result = layer_data->device_dispatch_table.BindImageMemory2(device, bindInfoCount, (const VkBindImageMemoryInfo*)local_pBindInfos);
     if (local_pBindInfos) {
-        for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
-            FreeUnwrappedExtensionStructs(const_cast<void *>(local_pBindInfos[index0].pNext));
-        }
         delete[] local_pBindInfos;
     }
     return result;
@@ -5315,7 +3329,6 @@ void DispatchGetImageMemoryRequirements2(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
     safe_VkImageMemoryRequirementsInfo2 *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkImageMemoryRequirementsInfo2(pInfo);
             if (pInfo->image) {
@@ -5338,7 +3351,6 @@ void DispatchGetBufferMemoryRequirements2(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
     safe_VkBufferMemoryRequirementsInfo2 *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkBufferMemoryRequirementsInfo2(pInfo);
             if (pInfo->buffer) {
@@ -5362,7 +3374,6 @@ void DispatchGetImageSparseMemoryRequirements2(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
     safe_VkImageSparseMemoryRequirementsInfo2 *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkImageSparseMemoryRequirementsInfo2(pInfo);
             if (pInfo->image) {
@@ -5413,15 +3424,13 @@ VkResult DispatchGetPhysicalDeviceImageFormatProperties2(
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
     safe_VkPhysicalDeviceImageFormatInfo2 *local_pImageFormatInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pImageFormatInfo) {
             local_pImageFormatInfo = new safe_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
-            local_pImageFormatInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pImageFormatInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pImageFormatInfo->pNext);
         }
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDeviceImageFormatProperties2(physicalDevice, (const VkPhysicalDeviceImageFormatInfo2*)local_pImageFormatInfo, pImageFormatProperties);
     if (local_pImageFormatInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pImageFormatInfo->pNext));
         delete local_pImageFormatInfo;
     }
     return result;
@@ -5465,7 +3474,6 @@ void DispatchTrimCommandPool(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.TrimCommandPool(device, commandPool, flags);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         commandPool = layer_data->Unwrap(commandPool);
     }
     layer_data->device_dispatch_table.TrimCommandPool(device, commandPool, flags);
@@ -5492,19 +3500,16 @@ VkResult DispatchCreateSamplerYcbcrConversion(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
     safe_VkSamplerYcbcrConversionCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkSamplerYcbcrConversionCreateInfo(pCreateInfo);
-            local_pCreateInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pCreateInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pCreateInfo->pNext);
         }
     }
     VkResult result = layer_data->device_dispatch_table.CreateSamplerYcbcrConversion(device, (const VkSamplerYcbcrConversionCreateInfo*)local_pCreateInfo, pAllocator, pYcbcrConversion);
     if (local_pCreateInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pCreateInfo->pNext));
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pYcbcrConversion = layer_data->WrapNew(*pYcbcrConversion);
     }
     return result;
@@ -5517,11 +3522,13 @@ void DispatchDestroySamplerYcbcrConversion(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t ycbcrConversion_id = reinterpret_cast<uint64_t &>(ycbcrConversion);
-    ycbcrConversion = (VkSamplerYcbcrConversion)unique_id_mapping[ycbcrConversion_id];
-    unique_id_mapping.erase(ycbcrConversion_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(ycbcrConversion_id);
+    if (iter != unique_id_mapping.end()) {
+        ycbcrConversion = (VkSamplerYcbcrConversion)iter->second;
+    } else {
+        ycbcrConversion = (VkSamplerYcbcrConversion)0;
+    }
     layer_data->device_dispatch_table.DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
 
 }
@@ -5571,7 +3578,6 @@ void DispatchGetDescriptorSetLayoutSupport(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
     safe_VkDescriptorSetLayoutCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
             if (local_pCreateInfo->pBindings) {
@@ -5598,11 +3604,13 @@ void DispatchDestroySurfaceKHR(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.DestroySurfaceKHR(instance, surface, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t surface_id = reinterpret_cast<uint64_t &>(surface);
-    surface = (VkSurfaceKHR)unique_id_mapping[surface_id];
-    unique_id_mapping.erase(surface_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(surface_id);
+    if (iter != unique_id_mapping.end()) {
+        surface = (VkSurfaceKHR)iter->second;
+    } else {
+        surface = (VkSurfaceKHR)0;
+    }
     layer_data->instance_dispatch_table.DestroySurfaceKHR(instance, surface, pAllocator);
 
 }
@@ -5616,7 +3624,6 @@ VkResult DispatchGetPhysicalDeviceSurfaceSupportKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         surface = layer_data->Unwrap(surface);
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported);
@@ -5632,7 +3639,6 @@ VkResult DispatchGetPhysicalDeviceSurfaceCapabilitiesKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         surface = layer_data->Unwrap(surface);
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities);
@@ -5649,7 +3655,6 @@ VkResult DispatchGetPhysicalDeviceSurfaceFormatsKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         surface = layer_data->Unwrap(surface);
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats);
@@ -5666,7 +3671,6 @@ VkResult DispatchGetPhysicalDeviceSurfacePresentModesKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         surface = layer_data->Unwrap(surface);
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes);
@@ -5691,7 +3695,6 @@ VkResult DispatchAcquireNextImageKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
         semaphore = layer_data->Unwrap(semaphore);
         fence = layer_data->Unwrap(fence);
@@ -5721,7 +3724,6 @@ VkResult DispatchGetDeviceGroupSurfacePresentModesKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         surface = layer_data->Unwrap(surface);
     }
     VkResult result = layer_data->device_dispatch_table.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes);
@@ -5738,7 +3740,6 @@ VkResult DispatchGetPhysicalDevicePresentRectanglesKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         surface = layer_data->Unwrap(surface);
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects);
@@ -5755,7 +3756,6 @@ VkResult DispatchAcquireNextImage2KHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex);
     safe_VkAcquireNextImageInfoKHR *local_pAcquireInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pAcquireInfo) {
             local_pAcquireInfo = new safe_VkAcquireNextImageInfoKHR(pAcquireInfo);
             if (pAcquireInfo->swapchain) {
@@ -5794,12 +3794,10 @@ VkResult DispatchCreateDisplayModeKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
     VkResult result = layer_data->instance_dispatch_table.CreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pMode = layer_data->WrapNew(*pMode);
     }
     return result;
@@ -5814,7 +3812,6 @@ VkResult DispatchGetDisplayPlaneCapabilitiesKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         mode = layer_data->Unwrap(mode);
     }
     VkResult result = layer_data->instance_dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
@@ -5832,7 +3829,6 @@ VkResult DispatchCreateDisplayPlaneSurfaceKHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     safe_VkDisplaySurfaceCreateInfoKHR *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkDisplaySurfaceCreateInfoKHR(pCreateInfo);
             if (pCreateInfo->displayMode) {
@@ -5845,7 +3841,6 @@ VkResult DispatchCreateDisplayPlaneSurfaceKHR(
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -5865,7 +3860,6 @@ VkResult DispatchCreateXlibSurfaceKHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -5899,7 +3893,6 @@ VkResult DispatchCreateXcbSurfaceKHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -5933,7 +3926,6 @@ VkResult DispatchCreateWaylandSurfaceKHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -5966,7 +3958,6 @@ VkResult DispatchCreateAndroidSurfaceKHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -5985,7 +3976,6 @@ VkResult DispatchCreateWin32SurfaceKHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -6042,15 +4032,13 @@ VkResult DispatchGetPhysicalDeviceImageFormatProperties2KHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties);
     safe_VkPhysicalDeviceImageFormatInfo2 *local_pImageFormatInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pImageFormatInfo) {
             local_pImageFormatInfo = new safe_VkPhysicalDeviceImageFormatInfo2(pImageFormatInfo);
-            local_pImageFormatInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pImageFormatInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pImageFormatInfo->pNext);
         }
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, (const VkPhysicalDeviceImageFormatInfo2*)local_pImageFormatInfo, pImageFormatProperties);
     if (local_pImageFormatInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pImageFormatInfo->pNext));
         delete local_pImageFormatInfo;
     }
     return result;
@@ -6129,7 +4117,6 @@ void DispatchTrimCommandPoolKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.TrimCommandPoolKHR(device, commandPool, flags);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         commandPool = layer_data->Unwrap(commandPool);
     }
     layer_data->device_dispatch_table.TrimCommandPoolKHR(device, commandPool, flags);
@@ -6168,7 +4155,6 @@ VkResult DispatchGetMemoryWin32HandleKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
     safe_VkMemoryGetWin32HandleInfoKHR *local_pGetWin32HandleInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pGetWin32HandleInfo) {
             local_pGetWin32HandleInfo = new safe_VkMemoryGetWin32HandleInfoKHR(pGetWin32HandleInfo);
             if (pGetWin32HandleInfo->memory) {
@@ -6208,7 +4194,6 @@ VkResult DispatchGetMemoryFdKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetMemoryFdKHR(device, pGetFdInfo, pFd);
     safe_VkMemoryGetFdInfoKHR *local_pGetFdInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pGetFdInfo) {
             local_pGetFdInfo = new safe_VkMemoryGetFdInfoKHR(pGetFdInfo);
             if (pGetFdInfo->memory) {
@@ -6255,7 +4240,6 @@ VkResult DispatchImportSemaphoreWin32HandleKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo);
     safe_VkImportSemaphoreWin32HandleInfoKHR *local_pImportSemaphoreWin32HandleInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pImportSemaphoreWin32HandleInfo) {
             local_pImportSemaphoreWin32HandleInfo = new safe_VkImportSemaphoreWin32HandleInfoKHR(pImportSemaphoreWin32HandleInfo);
             if (pImportSemaphoreWin32HandleInfo->semaphore) {
@@ -6282,7 +4266,6 @@ VkResult DispatchGetSemaphoreWin32HandleKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
     safe_VkSemaphoreGetWin32HandleInfoKHR *local_pGetWin32HandleInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pGetWin32HandleInfo) {
             local_pGetWin32HandleInfo = new safe_VkSemaphoreGetWin32HandleInfoKHR(pGetWin32HandleInfo);
             if (pGetWin32HandleInfo->semaphore) {
@@ -6306,7 +4289,6 @@ VkResult DispatchImportSemaphoreFdKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo);
     safe_VkImportSemaphoreFdInfoKHR *local_pImportSemaphoreFdInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pImportSemaphoreFdInfo) {
             local_pImportSemaphoreFdInfo = new safe_VkImportSemaphoreFdInfoKHR(pImportSemaphoreFdInfo);
             if (pImportSemaphoreFdInfo->semaphore) {
@@ -6330,7 +4312,6 @@ VkResult DispatchGetSemaphoreFdKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetSemaphoreFdKHR(device, pGetFdInfo, pFd);
     safe_VkSemaphoreGetFdInfoKHR *local_pGetFdInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pGetFdInfo) {
             local_pGetFdInfo = new safe_VkSemaphoreGetFdInfoKHR(pGetFdInfo);
             if (pGetFdInfo->semaphore) {
@@ -6357,13 +4338,12 @@ void DispatchCmdPushDescriptorSetKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites);
     safe_VkWriteDescriptorSet *local_pDescriptorWrites = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         layout = layer_data->Unwrap(layout);
         if (pDescriptorWrites) {
             local_pDescriptorWrites = new safe_VkWriteDescriptorSet[descriptorWriteCount];
             for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
                 local_pDescriptorWrites[index0].initialize(&pDescriptorWrites[index0]);
-                local_pDescriptorWrites[index0].pNext = CreateUnwrappedExtensionStructs(layer_data, local_pDescriptorWrites[index0].pNext);
+                WrapPnextChainHandles(layer_data, local_pDescriptorWrites[index0].pNext);
                 if (pDescriptorWrites[index0].dstSet) {
                     local_pDescriptorWrites[index0].dstSet = layer_data->Unwrap(pDescriptorWrites[index0].dstSet);
                 }
@@ -6394,9 +4374,6 @@ void DispatchCmdPushDescriptorSetKHR(
     }
     layer_data->device_dispatch_table.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, (const VkWriteDescriptorSet*)local_pDescriptorWrites);
     if (local_pDescriptorWrites) {
-        for (uint32_t index0 = 0; index0 < descriptorWriteCount; ++index0) {
-            FreeUnwrappedExtensionStructs(const_cast<void *>(local_pDescriptorWrites[index0].pNext));
-        }
         delete[] local_pDescriptorWrites;
     }
 }
@@ -6420,7 +4397,6 @@ void DispatchCmdBeginRenderPass2KHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo);
     safe_VkRenderPassBeginInfo *local_pRenderPassBegin = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pRenderPassBegin) {
             local_pRenderPassBegin = new safe_VkRenderPassBeginInfo(pRenderPassBegin);
             if (pRenderPassBegin->renderPass) {
@@ -6429,12 +4405,11 @@ void DispatchCmdBeginRenderPass2KHR(
             if (pRenderPassBegin->framebuffer) {
                 local_pRenderPassBegin->framebuffer = layer_data->Unwrap(pRenderPassBegin->framebuffer);
             }
-            local_pRenderPassBegin->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pRenderPassBegin->pNext);
+            WrapPnextChainHandles(layer_data, local_pRenderPassBegin->pNext);
         }
     }
     layer_data->device_dispatch_table.CmdBeginRenderPass2KHR(commandBuffer, (const VkRenderPassBeginInfo*)local_pRenderPassBegin, pSubpassBeginInfo);
     if (local_pRenderPassBegin) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pRenderPassBegin->pNext));
         delete local_pRenderPassBegin;
     }
 }
@@ -6465,7 +4440,6 @@ VkResult DispatchGetSwapchainStatusKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetSwapchainStatusKHR(device, swapchain);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result = layer_data->device_dispatch_table.GetSwapchainStatusKHR(device, swapchain);
@@ -6493,7 +4467,6 @@ VkResult DispatchImportFenceWin32HandleKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo);
     safe_VkImportFenceWin32HandleInfoKHR *local_pImportFenceWin32HandleInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pImportFenceWin32HandleInfo) {
             local_pImportFenceWin32HandleInfo = new safe_VkImportFenceWin32HandleInfoKHR(pImportFenceWin32HandleInfo);
             if (pImportFenceWin32HandleInfo->fence) {
@@ -6520,7 +4493,6 @@ VkResult DispatchGetFenceWin32HandleKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
     safe_VkFenceGetWin32HandleInfoKHR *local_pGetWin32HandleInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pGetWin32HandleInfo) {
             local_pGetWin32HandleInfo = new safe_VkFenceGetWin32HandleInfoKHR(pGetWin32HandleInfo);
             if (pGetWin32HandleInfo->fence) {
@@ -6544,7 +4516,6 @@ VkResult DispatchImportFenceFdKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.ImportFenceFdKHR(device, pImportFenceFdInfo);
     safe_VkImportFenceFdInfoKHR *local_pImportFenceFdInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pImportFenceFdInfo) {
             local_pImportFenceFdInfo = new safe_VkImportFenceFdInfoKHR(pImportFenceFdInfo);
             if (pImportFenceFdInfo->fence) {
@@ -6568,7 +4539,6 @@ VkResult DispatchGetFenceFdKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetFenceFdKHR(device, pGetFdInfo, pFd);
     safe_VkFenceGetFdInfoKHR *local_pGetFdInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pGetFdInfo) {
             local_pGetFdInfo = new safe_VkFenceGetFdInfoKHR(pGetFdInfo);
             if (pGetFdInfo->fence) {
@@ -6592,7 +4562,6 @@ VkResult DispatchGetPhysicalDeviceSurfaceCapabilities2KHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
     safe_VkPhysicalDeviceSurfaceInfo2KHR *local_pSurfaceInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pSurfaceInfo) {
             local_pSurfaceInfo = new safe_VkPhysicalDeviceSurfaceInfo2KHR(pSurfaceInfo);
             if (pSurfaceInfo->surface) {
@@ -6617,7 +4586,6 @@ VkResult DispatchGetPhysicalDeviceSurfaceFormats2KHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats);
     safe_VkPhysicalDeviceSurfaceInfo2KHR *local_pSurfaceInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pSurfaceInfo) {
             local_pSurfaceInfo = new safe_VkPhysicalDeviceSurfaceInfo2KHR(pSurfaceInfo);
             if (pSurfaceInfo->surface) {
@@ -6647,7 +4615,6 @@ VkResult DispatchGetDisplayPlaneCapabilities2KHR(
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities);
     safe_VkDisplayPlaneInfo2KHR *local_pDisplayPlaneInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pDisplayPlaneInfo) {
             local_pDisplayPlaneInfo = new safe_VkDisplayPlaneInfo2KHR(pDisplayPlaneInfo);
             if (pDisplayPlaneInfo->mode) {
@@ -6671,7 +4638,6 @@ void DispatchGetImageMemoryRequirements2KHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
     safe_VkImageMemoryRequirementsInfo2 *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkImageMemoryRequirementsInfo2(pInfo);
             if (pInfo->image) {
@@ -6694,7 +4660,6 @@ void DispatchGetBufferMemoryRequirements2KHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements);
     safe_VkBufferMemoryRequirementsInfo2 *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkBufferMemoryRequirementsInfo2(pInfo);
             if (pInfo->buffer) {
@@ -6718,7 +4683,6 @@ void DispatchGetImageSparseMemoryRequirements2KHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
     safe_VkImageSparseMemoryRequirementsInfo2 *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkImageSparseMemoryRequirementsInfo2(pInfo);
             if (pInfo->image) {
@@ -6742,19 +4706,16 @@ VkResult DispatchCreateSamplerYcbcrConversionKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion);
     safe_VkSamplerYcbcrConversionCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkSamplerYcbcrConversionCreateInfo(pCreateInfo);
-            local_pCreateInfo->pNext = CreateUnwrappedExtensionStructs(layer_data, local_pCreateInfo->pNext);
+            WrapPnextChainHandles(layer_data, local_pCreateInfo->pNext);
         }
     }
     VkResult result = layer_data->device_dispatch_table.CreateSamplerYcbcrConversionKHR(device, (const VkSamplerYcbcrConversionCreateInfo*)local_pCreateInfo, pAllocator, pYcbcrConversion);
     if (local_pCreateInfo) {
-        FreeUnwrappedExtensionStructs(const_cast<void *>(local_pCreateInfo->pNext));
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pYcbcrConversion = layer_data->WrapNew(*pYcbcrConversion);
     }
     return result;
@@ -6767,11 +4728,13 @@ void DispatchDestroySamplerYcbcrConversionKHR(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t ycbcrConversion_id = reinterpret_cast<uint64_t &>(ycbcrConversion);
-    ycbcrConversion = (VkSamplerYcbcrConversion)unique_id_mapping[ycbcrConversion_id];
-    unique_id_mapping.erase(ycbcrConversion_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(ycbcrConversion_id);
+    if (iter != unique_id_mapping.end()) {
+        ycbcrConversion = (VkSamplerYcbcrConversion)iter->second;
+    } else {
+        ycbcrConversion = (VkSamplerYcbcrConversion)0;
+    }
     layer_data->device_dispatch_table.DestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator);
 
 }
@@ -6785,7 +4748,6 @@ VkResult DispatchBindBufferMemory2KHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.BindBufferMemory2KHR(device, bindInfoCount, pBindInfos);
     safe_VkBindBufferMemoryInfo *local_pBindInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBindInfos) {
             local_pBindInfos = new safe_VkBindBufferMemoryInfo[bindInfoCount];
             for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
@@ -6815,12 +4777,11 @@ VkResult DispatchBindImageMemory2KHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.BindImageMemory2KHR(device, bindInfoCount, pBindInfos);
     safe_VkBindImageMemoryInfo *local_pBindInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBindInfos) {
             local_pBindInfos = new safe_VkBindImageMemoryInfo[bindInfoCount];
             for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
                 local_pBindInfos[index0].initialize(&pBindInfos[index0]);
-                local_pBindInfos[index0].pNext = CreateUnwrappedExtensionStructs(layer_data, local_pBindInfos[index0].pNext);
+                WrapPnextChainHandles(layer_data, local_pBindInfos[index0].pNext);
                 if (pBindInfos[index0].image) {
                     local_pBindInfos[index0].image = layer_data->Unwrap(pBindInfos[index0].image);
                 }
@@ -6832,9 +4793,6 @@ VkResult DispatchBindImageMemory2KHR(
     }
     VkResult result = layer_data->device_dispatch_table.BindImageMemory2KHR(device, bindInfoCount, (const VkBindImageMemoryInfo*)local_pBindInfos);
     if (local_pBindInfos) {
-        for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
-            FreeUnwrappedExtensionStructs(const_cast<void *>(local_pBindInfos[index0].pNext));
-        }
         delete[] local_pBindInfos;
     }
     return result;
@@ -6849,7 +4807,6 @@ void DispatchGetDescriptorSetLayoutSupportKHR(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport);
     safe_VkDescriptorSetLayoutCreateInfo *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
             if (local_pCreateInfo->pBindings) {
@@ -6881,7 +4838,6 @@ void DispatchCmdDrawIndirectCountKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
         countBuffer = layer_data->Unwrap(countBuffer);
     }
@@ -6901,7 +4857,6 @@ void DispatchCmdDrawIndexedIndirectCountKHR(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawIndexedIndirectCountKHR(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
         countBuffer = layer_data->Unwrap(countBuffer);
     }
@@ -6909,6 +4864,78 @@ void DispatchCmdDrawIndexedIndirectCountKHR(
 
 }
 
+VkResult DispatchGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties)
+{
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+    if (!wrap_handles) return layer_data->device_dispatch_table.GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties);
+    safe_VkPipelineInfoKHR *local_pPipelineInfo = NULL;
+    {
+        if (pPipelineInfo) {
+            local_pPipelineInfo = new safe_VkPipelineInfoKHR(pPipelineInfo);
+            if (pPipelineInfo->pipeline) {
+                local_pPipelineInfo->pipeline = layer_data->Unwrap(pPipelineInfo->pipeline);
+            }
+        }
+    }
+    VkResult result = layer_data->device_dispatch_table.GetPipelineExecutablePropertiesKHR(device, (const VkPipelineInfoKHR*)local_pPipelineInfo, pExecutableCount, pProperties);
+    if (local_pPipelineInfo) {
+        delete local_pPipelineInfo;
+    }
+    return result;
+}
+
+VkResult DispatchGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics)
+{
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+    if (!wrap_handles) return layer_data->device_dispatch_table.GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics);
+    safe_VkPipelineExecutableInfoKHR *local_pExecutableInfo = NULL;
+    {
+        if (pExecutableInfo) {
+            local_pExecutableInfo = new safe_VkPipelineExecutableInfoKHR(pExecutableInfo);
+            if (pExecutableInfo->pipeline) {
+                local_pExecutableInfo->pipeline = layer_data->Unwrap(pExecutableInfo->pipeline);
+            }
+        }
+    }
+    VkResult result = layer_data->device_dispatch_table.GetPipelineExecutableStatisticsKHR(device, (const VkPipelineExecutableInfoKHR*)local_pExecutableInfo, pStatisticCount, pStatistics);
+    if (local_pExecutableInfo) {
+        delete local_pExecutableInfo;
+    }
+    return result;
+}
+
+VkResult DispatchGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations)
+{
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
+    if (!wrap_handles) return layer_data->device_dispatch_table.GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+    safe_VkPipelineExecutableInfoKHR *local_pExecutableInfo = NULL;
+    {
+        if (pExecutableInfo) {
+            local_pExecutableInfo = new safe_VkPipelineExecutableInfoKHR(pExecutableInfo);
+            if (pExecutableInfo->pipeline) {
+                local_pExecutableInfo->pipeline = layer_data->Unwrap(pExecutableInfo->pipeline);
+            }
+        }
+    }
+    VkResult result = layer_data->device_dispatch_table.GetPipelineExecutableInternalRepresentationsKHR(device, (const VkPipelineExecutableInfoKHR*)local_pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations);
+    if (local_pExecutableInfo) {
+        delete local_pExecutableInfo;
+    }
+    return result;
+}
+
 VkResult DispatchCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -6919,7 +4946,6 @@ VkResult DispatchCreateDebugReportCallbackEXT(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
     VkResult result = layer_data->instance_dispatch_table.CreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pCallback = layer_data->WrapNew(*pCallback);
     }
     return result;
@@ -6932,11 +4958,13 @@ void DispatchDestroyDebugReportCallbackEXT(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t callback_id = reinterpret_cast<uint64_t &>(callback);
-    callback = (VkDebugReportCallbackEXT)unique_id_mapping[callback_id];
-    unique_id_mapping.erase(callback_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(callback_id);
+    if (iter != unique_id_mapping.end()) {
+        callback = (VkDebugReportCallbackEXT)iter->second;
+    } else {
+        callback = (VkDebugReportCallbackEXT)0;
+    }
     layer_data->instance_dispatch_table.DestroyDebugReportCallbackEXT(instance, callback, pAllocator);
 
 }
@@ -6998,7 +5026,6 @@ void DispatchCmdBindTransformFeedbackBuffersEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes);
     VkBuffer *local_pBuffers = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBuffers) {
             local_pBuffers = new VkBuffer[bindingCount];
             for (uint32_t index0 = 0; index0 < bindingCount; ++index0) {
@@ -7022,7 +5049,6 @@ void DispatchCmdBeginTransformFeedbackEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
     VkBuffer *local_pCounterBuffers = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCounterBuffers) {
             local_pCounterBuffers = new VkBuffer[counterBufferCount];
             for (uint32_t index0 = 0; index0 < counterBufferCount; ++index0) {
@@ -7046,7 +5072,6 @@ void DispatchCmdEndTransformFeedbackEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets);
     VkBuffer *local_pCounterBuffers = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCounterBuffers) {
             local_pCounterBuffers = new VkBuffer[counterBufferCount];
             for (uint32_t index0 = 0; index0 < counterBufferCount; ++index0) {
@@ -7069,7 +5094,6 @@ void DispatchCmdBeginQueryIndexedEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     layer_data->device_dispatch_table.CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index);
@@ -7085,7 +5109,6 @@ void DispatchCmdEndQueryIndexedEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     layer_data->device_dispatch_table.CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index);
@@ -7104,7 +5127,6 @@ void DispatchCmdDrawIndirectByteCountEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         counterBuffer = layer_data->Unwrap(counterBuffer);
     }
     layer_data->device_dispatch_table.CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride);
@@ -7119,7 +5141,6 @@ uint32_t DispatchGetImageViewHandleNVX(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageViewHandleNVX(device, pInfo);
     safe_VkImageViewHandleInfoNVX *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkImageViewHandleInfoNVX(pInfo);
             if (pInfo->imageView) {
@@ -7149,7 +5170,6 @@ void DispatchCmdDrawIndirectCountAMD(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
         countBuffer = layer_data->Unwrap(countBuffer);
     }
@@ -7169,7 +5189,6 @@ void DispatchCmdDrawIndexedIndirectCountAMD(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
         countBuffer = layer_data->Unwrap(countBuffer);
     }
@@ -7188,7 +5207,6 @@ VkResult DispatchGetShaderInfoAMD(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipeline = layer_data->Unwrap(pipeline);
     }
     VkResult result = layer_data->device_dispatch_table.GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo);
@@ -7208,7 +5226,6 @@ VkResult DispatchCreateStreamDescriptorSurfaceGGP(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -7242,7 +5259,6 @@ VkResult DispatchGetMemoryWin32HandleNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         memory = layer_data->Unwrap(memory);
     }
     VkResult result = layer_data->device_dispatch_table.GetMemoryWin32HandleNV(device, memory, handleType, pHandle);
@@ -7263,7 +5279,6 @@ VkResult DispatchCreateViSurfaceNN(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -7278,7 +5293,6 @@ void DispatchCmdBeginConditionalRenderingEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin);
     safe_VkConditionalRenderingBeginInfoEXT *local_pConditionalRenderingBegin = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pConditionalRenderingBegin) {
             local_pConditionalRenderingBegin = new safe_VkConditionalRenderingBeginInfoEXT(pConditionalRenderingBegin);
             if (pConditionalRenderingBegin->buffer) {
@@ -7308,7 +5322,6 @@ void DispatchCmdProcessCommandsNVX(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo);
     safe_VkCmdProcessCommandsInfoNVX *local_pProcessCommandsInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pProcessCommandsInfo) {
             local_pProcessCommandsInfo = new safe_VkCmdProcessCommandsInfoNVX(pProcessCommandsInfo);
             if (pProcessCommandsInfo->objectTable) {
@@ -7346,7 +5359,6 @@ void DispatchCmdReserveSpaceForCommandsNVX(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo);
     safe_VkCmdReserveSpaceForCommandsInfoNVX *local_pReserveSpaceInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pReserveSpaceInfo) {
             local_pReserveSpaceInfo = new safe_VkCmdReserveSpaceForCommandsInfoNVX(pReserveSpaceInfo);
             if (pReserveSpaceInfo->objectTable) {
@@ -7373,7 +5385,6 @@ VkResult DispatchCreateIndirectCommandsLayoutNVX(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
     VkResult result = layer_data->device_dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pIndirectCommandsLayout = layer_data->WrapNew(*pIndirectCommandsLayout);
     }
     return result;
@@ -7386,11 +5397,13 @@ void DispatchDestroyIndirectCommandsLayoutNVX(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t indirectCommandsLayout_id = reinterpret_cast<uint64_t &>(indirectCommandsLayout);
-    indirectCommandsLayout = (VkIndirectCommandsLayoutNVX)unique_id_mapping[indirectCommandsLayout_id];
-    unique_id_mapping.erase(indirectCommandsLayout_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(indirectCommandsLayout_id);
+    if (iter != unique_id_mapping.end()) {
+        indirectCommandsLayout = (VkIndirectCommandsLayoutNVX)iter->second;
+    } else {
+        indirectCommandsLayout = (VkIndirectCommandsLayoutNVX)0;
+    }
     layer_data->device_dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator);
 
 }
@@ -7405,7 +5418,6 @@ VkResult DispatchCreateObjectTableNVX(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
     VkResult result = layer_data->device_dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pObjectTable = layer_data->WrapNew(*pObjectTable);
     }
     return result;
@@ -7418,11 +5430,13 @@ void DispatchDestroyObjectTableNVX(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t objectTable_id = reinterpret_cast<uint64_t &>(objectTable);
-    objectTable = (VkObjectTableNVX)unique_id_mapping[objectTable_id];
-    unique_id_mapping.erase(objectTable_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(objectTable_id);
+    if (iter != unique_id_mapping.end()) {
+        objectTable = (VkObjectTableNVX)iter->second;
+    } else {
+        objectTable = (VkObjectTableNVX)0;
+    }
     layer_data->device_dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator);
 
 }
@@ -7437,7 +5451,6 @@ VkResult DispatchRegisterObjectsNVX(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         objectTable = layer_data->Unwrap(objectTable);
     }
     VkResult result = layer_data->device_dispatch_table.RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices);
@@ -7455,7 +5468,6 @@ VkResult DispatchUnregisterObjectsNVX(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         objectTable = layer_data->Unwrap(objectTable);
     }
     VkResult result = layer_data->device_dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices);
@@ -7491,7 +5503,6 @@ VkResult DispatchReleaseDisplayEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.ReleaseDisplayEXT(physicalDevice, display);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
     VkResult result = layer_data->instance_dispatch_table.ReleaseDisplayEXT(physicalDevice, display);
@@ -7509,7 +5520,6 @@ VkResult DispatchAcquireXlibDisplayEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
     VkResult result = layer_data->instance_dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display);
@@ -7530,7 +5540,6 @@ VkResult DispatchGetRandROutputDisplayEXT(
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
     VkResult result = layer_data->instance_dispatch_table.GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pDisplay = layer_data->WrapNew(*pDisplay);
     }
     return result;
@@ -7545,7 +5554,6 @@ VkResult DispatchGetPhysicalDeviceSurfaceCapabilities2EXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         surface = layer_data->Unwrap(surface);
     }
     VkResult result = layer_data->instance_dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities);
@@ -7561,7 +5569,6 @@ VkResult DispatchDisplayPowerControlEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
     VkResult result = layer_data->device_dispatch_table.DisplayPowerControlEXT(device, display, pDisplayPowerInfo);
@@ -7579,7 +5586,6 @@ VkResult DispatchRegisterDeviceEventEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
     VkResult result = layer_data->device_dispatch_table.RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pFence = layer_data->WrapNew(*pFence);
     }
     return result;
@@ -7595,12 +5601,10 @@ VkResult DispatchRegisterDisplayEventEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
     VkResult result = layer_data->device_dispatch_table.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pFence = layer_data->WrapNew(*pFence);
     }
     return result;
@@ -7615,7 +5619,6 @@ VkResult DispatchGetSwapchainCounterEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result = layer_data->device_dispatch_table.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue);
@@ -7631,7 +5634,6 @@ VkResult DispatchGetRefreshCycleDurationGOOGLE(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result = layer_data->device_dispatch_table.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties);
@@ -7648,7 +5650,6 @@ VkResult DispatchGetPastPresentationTimingGOOGLE(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result = layer_data->device_dispatch_table.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings);
@@ -7677,7 +5678,6 @@ void DispatchSetHdrMetadataEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
     VkSwapchainKHR *local_pSwapchains = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pSwapchains) {
             local_pSwapchains = new VkSwapchainKHR[swapchainCount];
             for (uint32_t index0 = 0; index0 < swapchainCount; ++index0) {
@@ -7702,7 +5702,6 @@ VkResult DispatchCreateIOSSurfaceMVK(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -7721,7 +5720,6 @@ VkResult DispatchCreateMacOSSurfaceMVK(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -7794,7 +5792,6 @@ VkResult DispatchCreateDebugUtilsMessengerEXT(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
     VkResult result = layer_data->instance_dispatch_table.CreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pMessenger = layer_data->WrapNew(*pMessenger);
     }
     return result;
@@ -7807,11 +5804,13 @@ void DispatchDestroyDebugUtilsMessengerEXT(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
     if (!wrap_handles) return layer_data->instance_dispatch_table.DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t messenger_id = reinterpret_cast<uint64_t &>(messenger);
-    messenger = (VkDebugUtilsMessengerEXT)unique_id_mapping[messenger_id];
-    unique_id_mapping.erase(messenger_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(messenger_id);
+    if (iter != unique_id_mapping.end()) {
+        messenger = (VkDebugUtilsMessengerEXT)iter->second;
+    } else {
+        messenger = (VkDebugUtilsMessengerEXT)0;
+    }
     layer_data->instance_dispatch_table.DestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator);
 
 }
@@ -7852,7 +5851,6 @@ VkResult DispatchGetMemoryAndroidHardwareBufferANDROID(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer);
     safe_VkMemoryGetAndroidHardwareBufferInfoANDROID *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(pInfo);
             if (pInfo->memory) {
@@ -7895,7 +5893,6 @@ VkResult DispatchGetImageDrmFormatModifierPropertiesEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         image = layer_data->Unwrap(image);
     }
     VkResult result = layer_data->device_dispatch_table.GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties);
@@ -7913,7 +5910,6 @@ VkResult DispatchCreateValidationCacheEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
     VkResult result = layer_data->device_dispatch_table.CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pValidationCache = layer_data->WrapNew(*pValidationCache);
     }
     return result;
@@ -7926,11 +5922,13 @@ void DispatchDestroyValidationCacheEXT(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyValidationCacheEXT(device, validationCache, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t validationCache_id = reinterpret_cast<uint64_t &>(validationCache);
-    validationCache = (VkValidationCacheEXT)unique_id_mapping[validationCache_id];
-    unique_id_mapping.erase(validationCache_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(validationCache_id);
+    if (iter != unique_id_mapping.end()) {
+        validationCache = (VkValidationCacheEXT)iter->second;
+    } else {
+        validationCache = (VkValidationCacheEXT)0;
+    }
     layer_data->device_dispatch_table.DestroyValidationCacheEXT(device, validationCache, pAllocator);
 
 }
@@ -7945,7 +5943,6 @@ VkResult DispatchMergeValidationCachesEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches);
     VkValidationCacheEXT *local_pSrcCaches = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         dstCache = layer_data->Unwrap(dstCache);
         if (pSrcCaches) {
             local_pSrcCaches = new VkValidationCacheEXT[srcCacheCount];
@@ -7969,7 +5966,6 @@ VkResult DispatchGetValidationCacheDataEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         validationCache = layer_data->Unwrap(validationCache);
     }
     VkResult result = layer_data->device_dispatch_table.GetValidationCacheDataEXT(device, validationCache, pDataSize, pData);
@@ -7985,7 +5981,6 @@ void DispatchCmdBindShadingRateImageNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         imageView = layer_data->Unwrap(imageView);
     }
     layer_data->device_dispatch_table.CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout);
@@ -8024,7 +6019,6 @@ VkResult DispatchCreateAccelerationStructureNV(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
     safe_VkAccelerationStructureCreateInfoNV *local_pCreateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_pCreateInfo = new safe_VkAccelerationStructureCreateInfoNV(pCreateInfo);
             if (local_pCreateInfo->info.pGeometries) {
@@ -8050,7 +6044,6 @@ VkResult DispatchCreateAccelerationStructureNV(
         delete local_pCreateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pAccelerationStructure = layer_data->WrapNew(*pAccelerationStructure);
     }
     return result;
@@ -8063,11 +6056,13 @@ void DispatchDestroyAccelerationStructureNV(
 {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t accelerationStructure_id = reinterpret_cast<uint64_t &>(accelerationStructure);
-    accelerationStructure = (VkAccelerationStructureNV)unique_id_mapping[accelerationStructure_id];
-    unique_id_mapping.erase(accelerationStructure_id);
-    lock.unlock();
+    auto iter = unique_id_mapping.pop(accelerationStructure_id);
+    if (iter != unique_id_mapping.end()) {
+        accelerationStructure = (VkAccelerationStructureNV)iter->second;
+    } else {
+        accelerationStructure = (VkAccelerationStructureNV)0;
+    }
     layer_data->device_dispatch_table.DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator);
 
 }
@@ -8081,7 +6076,6 @@ void DispatchGetAccelerationStructureMemoryRequirementsNV(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements);
     safe_VkAccelerationStructureMemoryRequirementsInfoNV *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkAccelerationStructureMemoryRequirementsInfoNV(pInfo);
             if (pInfo->accelerationStructure) {
@@ -8104,7 +6098,6 @@ VkResult DispatchBindAccelerationStructureMemoryNV(
     if (!wrap_handles) return layer_data->device_dispatch_table.BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos);
     safe_VkBindAccelerationStructureMemoryInfoNV *local_pBindInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pBindInfos) {
             local_pBindInfos = new safe_VkBindAccelerationStructureMemoryInfoNV[bindInfoCount];
             for (uint32_t index0 = 0; index0 < bindInfoCount; ++index0) {
@@ -8140,7 +6133,6 @@ void DispatchCmdBuildAccelerationStructureNV(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
     safe_VkAccelerationStructureInfoNV *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkAccelerationStructureInfoNV(pInfo);
             if (local_pInfo->pGeometries) {
@@ -8180,7 +6172,6 @@ void DispatchCmdCopyAccelerationStructureNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         dst = layer_data->Unwrap(dst);
         src = layer_data->Unwrap(src);
     }
@@ -8208,7 +6199,6 @@ void DispatchCmdTraceRaysNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         raygenShaderBindingTableBuffer = layer_data->Unwrap(raygenShaderBindingTableBuffer);
         missShaderBindingTableBuffer = layer_data->Unwrap(missShaderBindingTableBuffer);
         hitShaderBindingTableBuffer = layer_data->Unwrap(hitShaderBindingTableBuffer);
@@ -8230,7 +6220,6 @@ VkResult DispatchCreateRayTracingPipelinesNV(
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     safe_VkRayTracingPipelineCreateInfoNV *local_pCreateInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipelineCache = layer_data->Unwrap(pipelineCache);
         if (pCreateInfos) {
             local_pCreateInfos = new safe_VkRayTracingPipelineCreateInfoNV[createInfoCount];
@@ -8257,7 +6246,6 @@ VkResult DispatchCreateRayTracingPipelinesNV(
         delete[] local_pCreateInfos;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t index0 = 0; index0 < createInfoCount; index0++) {
             pPipelines[index0] = layer_data->WrapNew(pPipelines[index0]);
         }
@@ -8276,7 +6264,6 @@ VkResult DispatchGetRayTracingShaderGroupHandlesNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipeline = layer_data->Unwrap(pipeline);
     }
     VkResult result = layer_data->device_dispatch_table.GetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData);
@@ -8293,7 +6280,6 @@ VkResult DispatchGetAccelerationStructureHandleNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         accelerationStructure = layer_data->Unwrap(accelerationStructure);
     }
     VkResult result = layer_data->device_dispatch_table.GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
@@ -8313,7 +6299,6 @@ void DispatchCmdWriteAccelerationStructuresPropertiesNV(
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery);
     VkAccelerationStructureNV *local_pAccelerationStructures = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pAccelerationStructures) {
             local_pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
             for (uint32_t index0 = 0; index0 < accelerationStructureCount; ++index0) {
@@ -8335,7 +6320,6 @@ VkResult DispatchCompileDeferredNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CompileDeferredNV(device, pipeline, shader);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipeline = layer_data->Unwrap(pipeline);
     }
     VkResult result = layer_data->device_dispatch_table.CompileDeferredNV(device, pipeline, shader);
@@ -8365,7 +6349,6 @@ void DispatchCmdWriteBufferMarkerAMD(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         dstBuffer = layer_data->Unwrap(dstBuffer);
     }
     layer_data->device_dispatch_table.CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker);
@@ -8416,7 +6399,6 @@ void DispatchCmdDrawMeshTasksIndirectNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
     }
     layer_data->device_dispatch_table.CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
@@ -8435,7 +6417,6 @@ void DispatchCmdDrawMeshTasksIndirectCountNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         buffer = layer_data->Unwrap(buffer);
         countBuffer = layer_data->Unwrap(countBuffer);
     }
@@ -8529,7 +6510,6 @@ VkResult DispatchAcquirePerformanceConfigurationINTEL(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pConfiguration = layer_data->Unwrap(pConfiguration);
     }
     VkResult result = layer_data->device_dispatch_table.AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration);
@@ -8544,7 +6524,6 @@ VkResult DispatchReleasePerformanceConfigurationINTEL(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.ReleasePerformanceConfigurationINTEL(device, configuration);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         configuration = layer_data->Unwrap(configuration);
     }
     VkResult result = layer_data->device_dispatch_table.ReleasePerformanceConfigurationINTEL(device, configuration);
@@ -8559,7 +6538,6 @@ VkResult DispatchQueueSetPerformanceConfigurationINTEL(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.QueueSetPerformanceConfigurationINTEL(queue, configuration);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         configuration = layer_data->Unwrap(configuration);
     }
     VkResult result = layer_data->device_dispatch_table.QueueSetPerformanceConfigurationINTEL(queue, configuration);
@@ -8586,7 +6564,6 @@ void DispatchSetLocalDimmingAMD(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.SetLocalDimmingAMD(device, swapChain, localDimmingEnable);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapChain = layer_data->Unwrap(swapChain);
     }
     layer_data->device_dispatch_table.SetLocalDimmingAMD(device, swapChain, localDimmingEnable);
@@ -8605,7 +6582,6 @@ VkResult DispatchCreateImagePipeSurfaceFUCHSIA(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -8624,7 +6600,6 @@ VkResult DispatchCreateMetalSurfaceEXT(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
@@ -8639,7 +6614,6 @@ VkDeviceAddress DispatchGetBufferDeviceAddressEXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetBufferDeviceAddressEXT(device, pInfo);
     safe_VkBufferDeviceAddressInfoEXT *local_pInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pInfo) {
             local_pInfo = new safe_VkBufferDeviceAddressInfoEXT(pInfo);
             if (pInfo->buffer) {
@@ -8688,7 +6662,6 @@ VkResult DispatchGetPhysicalDeviceSurfacePresentModes2EXT(
     if (!wrap_handles) return layer_data->instance_dispatch_table.GetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes);
     safe_VkPhysicalDeviceSurfaceInfo2KHR *local_pSurfaceInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pSurfaceInfo) {
             local_pSurfaceInfo = new safe_VkPhysicalDeviceSurfaceInfo2KHR(pSurfaceInfo);
             if (pSurfaceInfo->surface) {
@@ -8713,7 +6686,6 @@ VkResult DispatchAcquireFullScreenExclusiveModeEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.AcquireFullScreenExclusiveModeEXT(device, swapchain);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result = layer_data->device_dispatch_table.AcquireFullScreenExclusiveModeEXT(device, swapchain);
@@ -8731,7 +6703,6 @@ VkResult DispatchReleaseFullScreenExclusiveModeEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.ReleaseFullScreenExclusiveModeEXT(device, swapchain);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result = layer_data->device_dispatch_table.ReleaseFullScreenExclusiveModeEXT(device, swapchain);
@@ -8751,7 +6722,6 @@ VkResult DispatchGetDeviceGroupSurfacePresentModes2EXT(
     if (!wrap_handles) return layer_data->device_dispatch_table.GetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes);
     safe_VkPhysicalDeviceSurfaceInfo2KHR *local_pSurfaceInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pSurfaceInfo) {
             local_pSurfaceInfo = new safe_VkPhysicalDeviceSurfaceInfo2KHR(pSurfaceInfo);
             if (pSurfaceInfo->surface) {
@@ -8777,12 +6747,21 @@ VkResult DispatchCreateHeadlessSurfaceEXT(
     if (!wrap_handles) return layer_data->instance_dispatch_table.CreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
     VkResult result = layer_data->instance_dispatch_table.CreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSurface = layer_data->WrapNew(*pSurface);
     }
     return result;
 }
 
+void DispatchCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern)
+{
+    auto layer_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map);
+    layer_data->device_dispatch_table.CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
+
+}
+
 void DispatchResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
@@ -8792,7 +6771,6 @@ void DispatchResetQueryPoolEXT(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         queryPool = layer_data->Unwrap(queryPool);
     }
     layer_data->device_dispatch_table.ResetQueryPoolEXT(device, queryPool, firstQuery, queryCount);
diff --git a/layers/generated/layer_chassis_dispatch.h b/layers/generated/layer_chassis_dispatch.h
index 5d013188c..2d4664931 100644
--- a/layers/generated/layer_chassis_dispatch.h
+++ b/layers/generated/layer_chassis_dispatch.h
@@ -1212,6 +1212,21 @@ void DispatchCmdDrawIndexedIndirectCountKHR(
     VkDeviceSize                                countBufferOffset,
     uint32_t                                    maxDrawCount,
     uint32_t                                    stride);
+VkResult DispatchGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties);
+VkResult DispatchGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics);
+VkResult DispatchGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
 VkResult DispatchCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -1767,6 +1782,10 @@ VkResult DispatchCreateHeadlessSurfaceEXT(
     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+void DispatchCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
 void DispatchResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
diff --git a/layers/generated/object_tracker.cpp b/layers/generated/object_tracker.cpp
index e82935314..3d3c0115c 100644
--- a/layers/generated/object_tracker.cpp
+++ b/layers/generated/object_tracker.cpp
@@ -1119,6 +1119,7 @@ bool ObjectLifetimes::PreCallValidateCreateComputePipelines(
     skip |= ValidateObject(device, pipelineCache, kVulkanObjectTypePipelineCache, true, "VUID-vkCreateComputePipelines-pipelineCache-parameter", "VUID-vkCreateComputePipelines-pipelineCache-parent");
     if (pCreateInfos) {
         for (uint32_t index0 = 0; index0 < createInfoCount; ++index0) {
+            skip |= ValidateObject(device, pCreateInfos[index0].stage.module, kVulkanObjectTypeShaderModule, false, "VUID-VkPipelineShaderStageCreateInfo-module-parameter", kVUIDUndefined);
             skip |= ValidateObject(device, pCreateInfos[index0].layout, kVulkanObjectTypePipelineLayout, false, "VUID-VkComputePipelineCreateInfo-layout-parameter", "VUID-VkComputePipelineCreateInfo-commonparent");
             skip |= ValidateObject(device, pCreateInfos[index0].basePipelineHandle, kVulkanObjectTypePipeline, true, kVUIDUndefined, "VUID-VkComputePipelineCreateInfo-commonparent");
         }
@@ -1298,36 +1299,6 @@ void ObjectLifetimes::PostCallRecordCreateDescriptorPool(
 
 }
 
-bool ObjectLifetimes::PreCallValidateCreateFramebuffer(
-    VkDevice                                    device,
-    const VkFramebufferCreateInfo*              pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFramebuffer*                              pFramebuffer) {
-    bool skip = false;
-    skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateFramebuffer-device-parameter", kVUIDUndefined);
-    if (pCreateInfo) {
-        skip |= ValidateObject(device, pCreateInfo->renderPass, kVulkanObjectTypeRenderPass, false, "VUID-VkFramebufferCreateInfo-renderPass-parameter", "VUID-VkFramebufferCreateInfo-commonparent");
-        if (pCreateInfo->pAttachments) {
-            for (uint32_t index1 = 0; index1 < pCreateInfo->attachmentCount; ++index1) {
-                skip |= ValidateObject(device, pCreateInfo->pAttachments[index1], kVulkanObjectTypeImageView, false, "VUID-VkFramebufferCreateInfo-pAttachments-parameter", "VUID-VkFramebufferCreateInfo-commonparent");
-            }
-        }
-    }
-
-    return skip;
-}
-
-void ObjectLifetimes::PostCallRecordCreateFramebuffer(
-    VkDevice                                    device,
-    const VkFramebufferCreateInfo*              pCreateInfo,
-    const VkAllocationCallbacks*                pAllocator,
-    VkFramebuffer*                              pFramebuffer,
-    VkResult                                    result) {
-    if (result != VK_SUCCESS) return;
-    CreateObject(device, *pFramebuffer, kVulkanObjectTypeFramebuffer, pAllocator);
-
-}
-
 bool ObjectLifetimes::PreCallValidateDestroyFramebuffer(
     VkDevice                                    device,
     VkFramebuffer                               framebuffer,
@@ -3489,6 +3460,48 @@ bool ObjectLifetimes::PreCallValidateCmdDrawIndexedIndirectCountKHR(
     return skip;
 }
 
+bool ObjectLifetimes::PreCallValidateGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties) {
+    bool skip = false;
+    skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter", kVUIDUndefined);
+    if (pPipelineInfo) {
+        skip |= ValidateObject(device, pPipelineInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineInfoKHR-pipeline-parameter", kVUIDUndefined);
+    }
+
+    return skip;
+}
+
+bool ObjectLifetimes::PreCallValidateGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics) {
+    bool skip = false;
+    skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter", kVUIDUndefined);
+    if (pExecutableInfo) {
+        skip |= ValidateObject(device, pExecutableInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineExecutableInfoKHR-pipeline-parameter", kVUIDUndefined);
+    }
+
+    return skip;
+}
+
+bool ObjectLifetimes::PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
+    bool skip = false;
+    skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter", kVUIDUndefined);
+    if (pExecutableInfo) {
+        skip |= ValidateObject(device, pExecutableInfo->pipeline, kVulkanObjectTypePipeline, false, "VUID-VkPipelineExecutableInfoKHR-pipeline-parameter", kVUIDUndefined);
+    }
+
+    return skip;
+}
+
 bool ObjectLifetimes::PreCallValidateCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -4526,6 +4539,14 @@ bool ObjectLifetimes::PreCallValidateCreateAccelerationStructureNV(
     bool skip = false;
     skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateAccelerationStructureNV-device-parameter", kVUIDUndefined);
     if (pCreateInfo) {
+        if (pCreateInfo->info.pGeometries) {
+            for (uint32_t index2 = 0; index2 < pCreateInfo->info.geometryCount; ++index2) {
+                skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.triangles.vertexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-vertexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
+                skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.triangles.indexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-indexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
+                skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.triangles.transformData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-transformData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
+                skip |= ValidateObject(device, pCreateInfo->info.pGeometries[index2].geometry.aabbs.aabbData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryAABBNV-aabbData-parameter", kVUIDUndefined);
+            }
+        }
     }
 
     return skip;
@@ -4606,6 +4627,10 @@ bool ObjectLifetimes::PreCallValidateCmdBuildAccelerationStructureNV(
     if (pInfo) {
         if (pInfo->pGeometries) {
             for (uint32_t index1 = 0; index1 < pInfo->geometryCount; ++index1) {
+                skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.triangles.vertexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-vertexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
+                skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.triangles.indexData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-indexData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
+                skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.triangles.transformData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryTrianglesNV-transformData-parameter", "VUID-VkGeometryTrianglesNV-commonparent");
+                skip |= ValidateObject(commandBuffer, pInfo->pGeometries[index1].geometry.aabbs.aabbData, kVulkanObjectTypeBuffer, true, "VUID-VkGeometryAABBNV-aabbData-parameter", kVUIDUndefined);
             }
         }
     }
@@ -5095,6 +5120,16 @@ void ObjectLifetimes::PostCallRecordCreateHeadlessSurfaceEXT(
 
 }
 
+bool ObjectLifetimes::PreCallValidateCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern) {
+    bool skip = false;
+    skip |= ValidateObject(commandBuffer, commandBuffer, kVulkanObjectTypeCommandBuffer, false, "VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter", kVUIDUndefined);
+
+    return skip;
+}
+
 bool ObjectLifetimes::PreCallValidateResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
diff --git a/layers/generated/object_tracker.h b/layers/generated/object_tracker.h
index 5f085ad37..4426a5e5f 100644
--- a/layers/generated/object_tracker.h
+++ b/layers/generated/object_tracker.h
@@ -1577,6 +1577,21 @@ bool PreCallValidateCmdDrawIndexedIndirectCountKHR(
     VkDeviceSize                                countBufferOffset,
     uint32_t                                    maxDrawCount,
     uint32_t                                    stride);
+bool PreCallValidateGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties);
+bool PreCallValidateGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics);
+bool PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
 bool PreCallValidateCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -2276,6 +2291,10 @@ void PostCallRecordCreateHeadlessSurfaceEXT(
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface,
     VkResult                                    result);
+bool PreCallValidateCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
 bool PreCallValidateResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
diff --git a/layers/generated/parameter_validation.cpp b/layers/generated/parameter_validation.cpp
index 35184be48..c09045bf4 100644
--- a/layers/generated/parameter_validation.cpp
+++ b/layers/generated/parameter_validation.cpp
@@ -27,7 +27,7 @@
 
 #include "stateless_validation.h"
 
-const uint32_t GeneratedVulkanHeaderVersion = 114;
+const uint32_t GeneratedVulkanHeaderVersion = 121;
 
 const VkAccessFlags AllVkAccessFlagBits = VK_ACCESS_INDIRECT_COMMAND_READ_BIT|VK_ACCESS_INDEX_READ_BIT|VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT|VK_ACCESS_UNIFORM_READ_BIT|VK_ACCESS_INPUT_ATTACHMENT_READ_BIT|VK_ACCESS_SHADER_READ_BIT|VK_ACCESS_SHADER_WRITE_BIT|VK_ACCESS_COLOR_ATTACHMENT_READ_BIT|VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT|VK_ACCESS_TRANSFER_READ_BIT|VK_ACCESS_TRANSFER_WRITE_BIT|VK_ACCESS_HOST_READ_BIT|VK_ACCESS_HOST_WRITE_BIT|VK_ACCESS_MEMORY_READ_BIT|VK_ACCESS_MEMORY_WRITE_BIT|VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT|VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT|VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT|VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT|VK_ACCESS_COMMAND_PROCESS_READ_BIT_NVX|VK_ACCESS_COMMAND_PROCESS_WRITE_BIT_NVX|VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT|VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV|VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV|VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV|VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT;
 const VkAttachmentDescriptionFlags AllVkAttachmentDescriptionFlagBits = VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT;
@@ -51,8 +51,9 @@ const VkImageCreateFlags AllVkImageCreateFlagBits = VK_IMAGE_CREATE_SPARSE_BINDI
 const VkImageUsageFlags AllVkImageUsageFlagBits = VK_IMAGE_USAGE_TRANSFER_SRC_BIT|VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT|VK_IMAGE_USAGE_STORAGE_BIT|VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT|VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT|VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT|VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT|VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV|VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT;
 const VkImageViewCreateFlags AllVkImageViewCreateFlagBits = VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT;
 const VkMemoryHeapFlags AllVkMemoryHeapFlagBits = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT|VK_MEMORY_HEAP_MULTI_INSTANCE_BIT|VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR;
-const VkMemoryPropertyFlags AllVkMemoryPropertyFlagBits = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT|VK_MEMORY_PROPERTY_PROTECTED_BIT;
-const VkPipelineCreateFlags AllVkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT|VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DERIVATIVE_BIT|VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT|VK_PIPELINE_CREATE_DISPATCH_BASE|VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR|VK_PIPELINE_CREATE_DISPATCH_BASE_KHR|VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV;
+const VkMemoryPropertyFlags AllVkMemoryPropertyFlagBits = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT|VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT|VK_MEMORY_PROPERTY_HOST_COHERENT_BIT|VK_MEMORY_PROPERTY_HOST_CACHED_BIT|VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT|VK_MEMORY_PROPERTY_PROTECTED_BIT|VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD|VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD;
+const VkPipelineCreateFlags AllVkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT|VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT|VK_PIPELINE_CREATE_DERIVATIVE_BIT|VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT|VK_PIPELINE_CREATE_DISPATCH_BASE|VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR|VK_PIPELINE_CREATE_DISPATCH_BASE_KHR|VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV|VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR|VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR;
+const VkPipelineShaderStageCreateFlags AllVkPipelineShaderStageCreateFlagBits = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT|VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT;
 const VkPipelineStageFlags AllVkPipelineStageFlagBits = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT|VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT|VK_PIPELINE_STAGE_VERTEX_INPUT_BIT|VK_PIPELINE_STAGE_VERTEX_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT|VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT|VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT|VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT|VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT|VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT|VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT|VK_PIPELINE_STAGE_TRANSFER_BIT|VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT|VK_PIPELINE_STAGE_HOST_BIT|VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT|VK_PIPELINE_STAGE_ALL_COMMANDS_BIT|VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT|VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT|VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX|VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV|VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV|VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV|VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV|VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV|VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT;
 const VkQueryControlFlags AllVkQueryControlFlagBits = VK_QUERY_CONTROL_PRECISE_BIT;
 const VkQueryPipelineStatisticFlags AllVkQueryPipelineStatisticFlagBits = VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT|VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT|VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT|VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT|VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT;
@@ -63,7 +64,7 @@ const VkSamplerCreateFlags AllVkSamplerCreateFlagBits = VK_SAMPLER_CREATE_SUBSAM
 const VkShaderStageFlags AllVkShaderStageFlagBits = VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT|VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT|VK_SHADER_STAGE_GEOMETRY_BIT|VK_SHADER_STAGE_FRAGMENT_BIT|VK_SHADER_STAGE_COMPUTE_BIT|VK_SHADER_STAGE_ALL_GRAPHICS|VK_SHADER_STAGE_ALL|VK_SHADER_STAGE_RAYGEN_BIT_NV|VK_SHADER_STAGE_ANY_HIT_BIT_NV|VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV|VK_SHADER_STAGE_MISS_BIT_NV|VK_SHADER_STAGE_INTERSECTION_BIT_NV|VK_SHADER_STAGE_CALLABLE_BIT_NV|VK_SHADER_STAGE_TASK_BIT_NV|VK_SHADER_STAGE_MESH_BIT_NV;
 const VkSparseImageFormatFlags AllVkSparseImageFormatFlagBits = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT|VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT|VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT;
 const VkSparseMemoryBindFlags AllVkSparseMemoryBindFlagBits = VK_SPARSE_MEMORY_BIND_METADATA_BIT;
-const VkStencilFaceFlags AllVkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_BIT|VK_STENCIL_FACE_BACK_BIT|VK_STENCIL_FRONT_AND_BACK;
+const VkStencilFaceFlags AllVkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_BIT|VK_STENCIL_FACE_BACK_BIT|VK_STENCIL_FACE_FRONT_AND_BACK|VK_STENCIL_FRONT_AND_BACK;
 const VkSubpassDescriptionFlags AllVkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX|VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX;
 const VkExternalFenceFeatureFlags AllVkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT|VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR|VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR;
 const VkExternalFenceHandleTypeFlags AllVkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT|VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR|VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR;
@@ -111,7 +112,7 @@ const std::vector<VkPipelineCacheHeaderVersion> AllVkPipelineCacheHeaderVersionE
 const std::vector<VkResult> AllVkResultEnums = {VK_SUCCESS, VK_NOT_READY, VK_TIMEOUT, VK_EVENT_SET, VK_EVENT_RESET, VK_INCOMPLETE, VK_ERROR_OUT_OF_HOST_MEMORY, VK_ERROR_OUT_OF_DEVICE_MEMORY, VK_ERROR_INITIALIZATION_FAILED, VK_ERROR_DEVICE_LOST, VK_ERROR_MEMORY_MAP_FAILED, VK_ERROR_LAYER_NOT_PRESENT, VK_ERROR_EXTENSION_NOT_PRESENT, VK_ERROR_FEATURE_NOT_PRESENT, VK_ERROR_INCOMPATIBLE_DRIVER, VK_ERROR_TOO_MANY_OBJECTS, VK_ERROR_FORMAT_NOT_SUPPORTED, VK_ERROR_FRAGMENTED_POOL, VK_ERROR_OUT_OF_POOL_MEMORY, VK_ERROR_INVALID_EXTERNAL_HANDLE, VK_ERROR_SURFACE_LOST_KHR, VK_ERROR_NATIVE_WINDOW_IN_USE_KHR, VK_SUBOPTIMAL_KHR, VK_ERROR_OUT_OF_DATE_KHR, VK_ERROR_INCOMPATIBLE_DISPLAY_KHR, VK_ERROR_VALIDATION_FAILED_EXT, VK_ERROR_INVALID_SHADER_NV, VK_ERROR_OUT_OF_POOL_MEMORY_KHR, VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR, VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT, VK_ERROR_FRAGMENTATION_EXT, VK_ERROR_NOT_PERMITTED_EXT, VK_ERROR_INVALID_DEVICE_ADDRESS_EXT, VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT, };
 const std::vector<VkSystemAllocationScope> AllVkSystemAllocationScopeEnums = {VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT, VK_SYSTEM_ALLOCATION_SCOPE_CACHE, VK_SYSTEM_ALLOCATION_SCOPE_DEVICE, VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, };
 const std::vector<VkInternalAllocationType> AllVkInternalAllocationTypeEnums = {VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, };
-const std::vector<VkFormat> AllVkFormatEnums = {VK_FORMAT_UNDEFINED, VK_FORMAT_R4G4_UNORM_PACK8, VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_R5G6B5_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_R5G5B5A1_UNORM_PACK16, VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_SNORM, VK_FORMAT_R8_USCALED, VK_FORMAT_R8_SSCALED, VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R8_SRGB, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8_USCALED, VK_FORMAT_R8G8_SSCALED, VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SRGB, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_R8G8B8_USCALED, VK_FORMAT_R8G8B8_SSCALED, VK_FORMAT_R8G8B8_UINT, VK_FORMAT_R8G8B8_SINT, VK_FORMAT_R8G8B8_SRGB, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_B8G8R8_SNORM, VK_FORMAT_B8G8R8_USCALED, VK_FORMAT_B8G8R8_SSCALED, VK_FORMAT_B8G8R8_UINT, VK_FORMAT_B8G8R8_SINT, VK_FORMAT_B8G8R8_SRGB, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_USCALED, VK_FORMAT_R8G8B8A8_SSCALED, VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SNORM, VK_FORMAT_B8G8R8A8_USCALED, VK_FORMAT_B8G8R8A8_SSCALED, VK_FORMAT_B8G8R8A8_UINT, VK_FORMAT_B8G8R8A8_SINT, VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_FORMAT_A8B8G8R8_SNORM_PACK32, VK_FORMAT_A8B8G8R8_USCALED_PACK32, VK_FORMAT_A8B8G8R8_SSCALED_PACK32, VK_FORMAT_A8B8G8R8_UINT_PACK32, VK_FORMAT_A8B8G8R8_SINT_PACK32, VK_FORMAT_A8B8G8R8_SRGB_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_A2R10G10B10_SNORM_PACK32, VK_FORMAT_A2R10G10B10_USCALED_PACK32, VK_FORMAT_A2R10G10B10_SSCALED_PACK32, VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_SINT_PACK32, VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_FORMAT_A2B10G10R10_SNORM_PACK32, VK_FORMAT_A2B10G10R10_USCALED_PACK32, VK_FORMAT_A2B10G10R10_SSCALED_PACK32, VK_FORMAT_A2B10G10R10_UINT_PACK32, VK_FORMAT_A2B10G10R10_SINT_PACK32, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_SNORM, VK_FORMAT_R16_USCALED, VK_FORMAT_R16_SSCALED, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R16_SFLOAT, VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16_USCALED, VK_FORMAT_R16G16_SSCALED, VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16B16_UNORM, VK_FORMAT_R16G16B16_SNORM, VK_FORMAT_R16G16B16_USCALED, VK_FORMAT_R16G16B16_SSCALED, VK_FORMAT_R16G16B16_UINT, VK_FORMAT_R16G16B16_SINT, VK_FORMAT_R16G16B16_SFLOAT, VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_USCALED, VK_FORMAT_R16G16B16A16_SSCALED, VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R32_UINT, VK_FORMAT_R32_SINT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_UINT, VK_FORMAT_R32G32B32_SINT, VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R64_UINT, VK_FORMAT_R64_SINT, VK_FORMAT_R64_SFLOAT, VK_FORMAT_R64G64_UINT, VK_FORMAT_R64G64_SINT, VK_FORMAT_R64G64_SFLOAT, VK_FORMAT_R64G64B64_UINT, VK_FORMAT_R64G64B64_SINT, VK_FORMAT_R64G64B64_SFLOAT, VK_FORMAT_R64G64B64A64_UINT, VK_FORMAT_R64G64B64A64_SINT, VK_FORMAT_R64G64B64A64_SFLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_D16_UNORM, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT, VK_FORMAT_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK, VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_SRGB_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_SNORM_BLOCK, VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_SNORM_BLOCK, VK_FORMAT_BC6H_UFLOAT_BLOCK, VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, VK_FORMAT_EAC_R11_UNORM_BLOCK, VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_EAC_R11G11_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, VK_FORMAT_G8B8G8R8_422_UNORM, VK_FORMAT_B8G8R8G8_422_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, VK_FORMAT_R10X6_UNORM_PACK16, VK_FORMAT_R10X6G10X6_UNORM_2PACK16, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, VK_FORMAT_R12X4_UNORM_PACK16, VK_FORMAT_R12X4G12X4_UNORM_2PACK16, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, VK_FORMAT_G16B16G16R16_422_UNORM, VK_FORMAT_B16G16R16G16_422_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, VK_FORMAT_G8B8G8R8_422_UNORM_KHR, VK_FORMAT_B8G8R8G8_422_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, VK_FORMAT_R10X6_UNORM_PACK16_KHR, VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, VK_FORMAT_R12X4_UNORM_PACK16_KHR, VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, VK_FORMAT_G16B16G16R16_422_UNORM_KHR, VK_FORMAT_B16G16R16G16_422_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, };
+const std::vector<VkFormat> AllVkFormatEnums = {VK_FORMAT_UNDEFINED, VK_FORMAT_R4G4_UNORM_PACK8, VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_R5G6B5_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_R5G5B5A1_UNORM_PACK16, VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_R8_UNORM, VK_FORMAT_R8_SNORM, VK_FORMAT_R8_USCALED, VK_FORMAT_R8_SSCALED, VK_FORMAT_R8_UINT, VK_FORMAT_R8_SINT, VK_FORMAT_R8_SRGB, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_SNORM, VK_FORMAT_R8G8_USCALED, VK_FORMAT_R8G8_SSCALED, VK_FORMAT_R8G8_UINT, VK_FORMAT_R8G8_SINT, VK_FORMAT_R8G8_SRGB, VK_FORMAT_R8G8B8_UNORM, VK_FORMAT_R8G8B8_SNORM, VK_FORMAT_R8G8B8_USCALED, VK_FORMAT_R8G8B8_SSCALED, VK_FORMAT_R8G8B8_UINT, VK_FORMAT_R8G8B8_SINT, VK_FORMAT_R8G8B8_SRGB, VK_FORMAT_B8G8R8_UNORM, VK_FORMAT_B8G8R8_SNORM, VK_FORMAT_B8G8R8_USCALED, VK_FORMAT_B8G8R8_SSCALED, VK_FORMAT_B8G8R8_UINT, VK_FORMAT_B8G8R8_SINT, VK_FORMAT_B8G8R8_SRGB, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SNORM, VK_FORMAT_R8G8B8A8_USCALED, VK_FORMAT_R8G8B8A8_SSCALED, VK_FORMAT_R8G8B8A8_UINT, VK_FORMAT_R8G8B8A8_SINT, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SNORM, VK_FORMAT_B8G8R8A8_USCALED, VK_FORMAT_B8G8R8A8_SSCALED, VK_FORMAT_B8G8R8A8_UINT, VK_FORMAT_B8G8R8A8_SINT, VK_FORMAT_B8G8R8A8_SRGB, VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_FORMAT_A8B8G8R8_SNORM_PACK32, VK_FORMAT_A8B8G8R8_USCALED_PACK32, VK_FORMAT_A8B8G8R8_SSCALED_PACK32, VK_FORMAT_A8B8G8R8_UINT_PACK32, VK_FORMAT_A8B8G8R8_SINT_PACK32, VK_FORMAT_A8B8G8R8_SRGB_PACK32, VK_FORMAT_A2R10G10B10_UNORM_PACK32, VK_FORMAT_A2R10G10B10_SNORM_PACK32, VK_FORMAT_A2R10G10B10_USCALED_PACK32, VK_FORMAT_A2R10G10B10_SSCALED_PACK32, VK_FORMAT_A2R10G10B10_UINT_PACK32, VK_FORMAT_A2R10G10B10_SINT_PACK32, VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_FORMAT_A2B10G10R10_SNORM_PACK32, VK_FORMAT_A2B10G10R10_USCALED_PACK32, VK_FORMAT_A2B10G10R10_SSCALED_PACK32, VK_FORMAT_A2B10G10R10_UINT_PACK32, VK_FORMAT_A2B10G10R10_SINT_PACK32, VK_FORMAT_R16_UNORM, VK_FORMAT_R16_SNORM, VK_FORMAT_R16_USCALED, VK_FORMAT_R16_SSCALED, VK_FORMAT_R16_UINT, VK_FORMAT_R16_SINT, VK_FORMAT_R16_SFLOAT, VK_FORMAT_R16G16_UNORM, VK_FORMAT_R16G16_SNORM, VK_FORMAT_R16G16_USCALED, VK_FORMAT_R16G16_SSCALED, VK_FORMAT_R16G16_UINT, VK_FORMAT_R16G16_SINT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16B16_UNORM, VK_FORMAT_R16G16B16_SNORM, VK_FORMAT_R16G16B16_USCALED, VK_FORMAT_R16G16B16_SSCALED, VK_FORMAT_R16G16B16_UINT, VK_FORMAT_R16G16B16_SINT, VK_FORMAT_R16G16B16_SFLOAT, VK_FORMAT_R16G16B16A16_UNORM, VK_FORMAT_R16G16B16A16_SNORM, VK_FORMAT_R16G16B16A16_USCALED, VK_FORMAT_R16G16B16A16_SSCALED, VK_FORMAT_R16G16B16A16_UINT, VK_FORMAT_R16G16B16A16_SINT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R32_UINT, VK_FORMAT_R32_SINT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_UINT, VK_FORMAT_R32G32_SINT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32_UINT, VK_FORMAT_R32G32B32_SINT, VK_FORMAT_R32G32B32_SFLOAT, VK_FORMAT_R32G32B32A32_UINT, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R64_UINT, VK_FORMAT_R64_SINT, VK_FORMAT_R64_SFLOAT, VK_FORMAT_R64G64_UINT, VK_FORMAT_R64G64_SINT, VK_FORMAT_R64G64_SFLOAT, VK_FORMAT_R64G64B64_UINT, VK_FORMAT_R64G64B64_SINT, VK_FORMAT_R64G64B64_SFLOAT, VK_FORMAT_R64G64B64A64_UINT, VK_FORMAT_R64G64B64A64_SINT, VK_FORMAT_R64G64B64A64_SFLOAT, VK_FORMAT_B10G11R11_UFLOAT_PACK32, VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, VK_FORMAT_D16_UNORM, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT, VK_FORMAT_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK, VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK, VK_FORMAT_BC3_SRGB_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_SNORM_BLOCK, VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_SNORM_BLOCK, VK_FORMAT_BC6H_UFLOAT_BLOCK, VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, VK_FORMAT_EAC_R11_UNORM_BLOCK, VK_FORMAT_EAC_R11_SNORM_BLOCK, VK_FORMAT_EAC_R11G11_UNORM_BLOCK, VK_FORMAT_EAC_R11G11_SNORM_BLOCK, VK_FORMAT_ASTC_4x4_UNORM_BLOCK, VK_FORMAT_ASTC_4x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x4_UNORM_BLOCK, VK_FORMAT_ASTC_5x4_SRGB_BLOCK, VK_FORMAT_ASTC_5x5_UNORM_BLOCK, VK_FORMAT_ASTC_5x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x5_UNORM_BLOCK, VK_FORMAT_ASTC_6x5_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x5_UNORM_BLOCK, VK_FORMAT_ASTC_8x5_SRGB_BLOCK, VK_FORMAT_ASTC_8x6_UNORM_BLOCK, VK_FORMAT_ASTC_8x6_SRGB_BLOCK, VK_FORMAT_ASTC_8x8_UNORM_BLOCK, VK_FORMAT_ASTC_8x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x5_UNORM_BLOCK, VK_FORMAT_ASTC_10x5_SRGB_BLOCK, VK_FORMAT_ASTC_10x6_UNORM_BLOCK, VK_FORMAT_ASTC_10x6_SRGB_BLOCK, VK_FORMAT_ASTC_10x8_UNORM_BLOCK, VK_FORMAT_ASTC_10x8_SRGB_BLOCK, VK_FORMAT_ASTC_10x10_UNORM_BLOCK, VK_FORMAT_ASTC_10x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x10_UNORM_BLOCK, VK_FORMAT_ASTC_12x10_SRGB_BLOCK, VK_FORMAT_ASTC_12x12_UNORM_BLOCK, VK_FORMAT_ASTC_12x12_SRGB_BLOCK, VK_FORMAT_G8B8G8R8_422_UNORM, VK_FORMAT_B8G8R8G8_422_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, VK_FORMAT_R10X6_UNORM_PACK16, VK_FORMAT_R10X6G10X6_UNORM_2PACK16, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, VK_FORMAT_R12X4_UNORM_PACK16, VK_FORMAT_R12X4G12X4_UNORM_2PACK16, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, VK_FORMAT_G16B16G16R16_422_UNORM, VK_FORMAT_B16G16R16G16_422_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT, VK_FORMAT_G8B8G8R8_422_UNORM_KHR, VK_FORMAT_B8G8R8G8_422_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR, VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR, VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR, VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR, VK_FORMAT_R10X6_UNORM_PACK16_KHR, VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR, VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR, VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR, VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR, VK_FORMAT_R12X4_UNORM_PACK16_KHR, VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR, VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR, VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR, VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR, VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR, VK_FORMAT_G16B16G16R16_422_UNORM_KHR, VK_FORMAT_B16G16R16G16_422_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR, VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR, VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR, VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR, };
 const std::vector<VkImageType> AllVkImageTypeEnums = {VK_IMAGE_TYPE_1D, VK_IMAGE_TYPE_2D, VK_IMAGE_TYPE_3D, };
 const std::vector<VkImageTiling> AllVkImageTilingEnums = {VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_TILING_LINEAR, VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT, };
 const std::vector<VkPhysicalDeviceType> AllVkPhysicalDeviceTypeEnums = {VK_PHYSICAL_DEVICE_TYPE_OTHER, VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU, VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU, VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU, VK_PHYSICAL_DEVICE_TYPE_CPU, };
@@ -129,17 +130,17 @@ const std::vector<VkStencilOp> AllVkStencilOpEnums = {VK_STENCIL_OP_KEEP, VK_STE
 const std::vector<VkLogicOp> AllVkLogicOpEnums = {VK_LOGIC_OP_CLEAR, VK_LOGIC_OP_AND, VK_LOGIC_OP_AND_REVERSE, VK_LOGIC_OP_COPY, VK_LOGIC_OP_AND_INVERTED, VK_LOGIC_OP_NO_OP, VK_LOGIC_OP_XOR, VK_LOGIC_OP_OR, VK_LOGIC_OP_NOR, VK_LOGIC_OP_EQUIVALENT, VK_LOGIC_OP_INVERT, VK_LOGIC_OP_OR_REVERSE, VK_LOGIC_OP_COPY_INVERTED, VK_LOGIC_OP_OR_INVERTED, VK_LOGIC_OP_NAND, VK_LOGIC_OP_SET, };
 const std::vector<VkBlendFactor> AllVkBlendFactorEnums = {VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_SRC_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, VK_BLEND_FACTOR_DST_COLOR, VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, VK_BLEND_FACTOR_SRC_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, VK_BLEND_FACTOR_DST_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, VK_BLEND_FACTOR_CONSTANT_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, VK_BLEND_FACTOR_SRC1_COLOR, VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR, VK_BLEND_FACTOR_SRC1_ALPHA, VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, };
 const std::vector<VkBlendOp> AllVkBlendOpEnums = {VK_BLEND_OP_ADD, VK_BLEND_OP_SUBTRACT, VK_BLEND_OP_REVERSE_SUBTRACT, VK_BLEND_OP_MIN, VK_BLEND_OP_MAX, VK_BLEND_OP_ZERO_EXT, VK_BLEND_OP_SRC_EXT, VK_BLEND_OP_DST_EXT, VK_BLEND_OP_SRC_OVER_EXT, VK_BLEND_OP_DST_OVER_EXT, VK_BLEND_OP_SRC_IN_EXT, VK_BLEND_OP_DST_IN_EXT, VK_BLEND_OP_SRC_OUT_EXT, VK_BLEND_OP_DST_OUT_EXT, VK_BLEND_OP_SRC_ATOP_EXT, VK_BLEND_OP_DST_ATOP_EXT, VK_BLEND_OP_XOR_EXT, VK_BLEND_OP_MULTIPLY_EXT, VK_BLEND_OP_SCREEN_EXT, VK_BLEND_OP_OVERLAY_EXT, VK_BLEND_OP_DARKEN_EXT, VK_BLEND_OP_LIGHTEN_EXT, VK_BLEND_OP_COLORDODGE_EXT, VK_BLEND_OP_COLORBURN_EXT, VK_BLEND_OP_HARDLIGHT_EXT, VK_BLEND_OP_SOFTLIGHT_EXT, VK_BLEND_OP_DIFFERENCE_EXT, VK_BLEND_OP_EXCLUSION_EXT, VK_BLEND_OP_INVERT_EXT, VK_BLEND_OP_INVERT_RGB_EXT, VK_BLEND_OP_LINEARDODGE_EXT, VK_BLEND_OP_LINEARBURN_EXT, VK_BLEND_OP_VIVIDLIGHT_EXT, VK_BLEND_OP_LINEARLIGHT_EXT, VK_BLEND_OP_PINLIGHT_EXT, VK_BLEND_OP_HARDMIX_EXT, VK_BLEND_OP_HSL_HUE_EXT, VK_BLEND_OP_HSL_SATURATION_EXT, VK_BLEND_OP_HSL_COLOR_EXT, VK_BLEND_OP_HSL_LUMINOSITY_EXT, VK_BLEND_OP_PLUS_EXT, VK_BLEND_OP_PLUS_CLAMPED_EXT, VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT, VK_BLEND_OP_PLUS_DARKER_EXT, VK_BLEND_OP_MINUS_EXT, VK_BLEND_OP_MINUS_CLAMPED_EXT, VK_BLEND_OP_CONTRAST_EXT, VK_BLEND_OP_INVERT_OVG_EXT, VK_BLEND_OP_RED_EXT, VK_BLEND_OP_GREEN_EXT, VK_BLEND_OP_BLUE_EXT, };
-const std::vector<VkDynamicState> AllVkDynamicStateEnums = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH, VK_DYNAMIC_STATE_DEPTH_BIAS, VK_DYNAMIC_STATE_BLEND_CONSTANTS, VK_DYNAMIC_STATE_DEPTH_BOUNDS, VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE, VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, };
+const std::vector<VkDynamicState> AllVkDynamicStateEnums = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_LINE_WIDTH, VK_DYNAMIC_STATE_DEPTH_BIAS, VK_DYNAMIC_STATE_BLEND_CONSTANTS, VK_DYNAMIC_STATE_DEPTH_BOUNDS, VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK, VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE, VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT, VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV, VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV, VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV, VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, };
 const std::vector<VkFilter> AllVkFilterEnums = {VK_FILTER_NEAREST, VK_FILTER_LINEAR, VK_FILTER_CUBIC_IMG, VK_FILTER_CUBIC_EXT, };
 const std::vector<VkSamplerMipmapMode> AllVkSamplerMipmapModeEnums = {VK_SAMPLER_MIPMAP_MODE_NEAREST, VK_SAMPLER_MIPMAP_MODE_LINEAR, };
-const std::vector<VkSamplerAddressMode> AllVkSamplerAddressModeEnums = {VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, };
+const std::vector<VkSamplerAddressMode> AllVkSamplerAddressModeEnums = {VK_SAMPLER_ADDRESS_MODE_REPEAT, VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR, };
 const std::vector<VkBorderColor> AllVkBorderColorEnums = {VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, VK_BORDER_COLOR_INT_TRANSPARENT_BLACK, VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK, VK_BORDER_COLOR_INT_OPAQUE_BLACK, VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE, VK_BORDER_COLOR_INT_OPAQUE_WHITE, };
 const std::vector<VkDescriptorType> AllVkDescriptorTypeEnums = {VK_DESCRIPTOR_TYPE_SAMPLER, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, };
 const std::vector<VkAttachmentLoadOp> AllVkAttachmentLoadOpEnums = {VK_ATTACHMENT_LOAD_OP_LOAD, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_LOAD_OP_DONT_CARE, };
 const std::vector<VkAttachmentStoreOp> AllVkAttachmentStoreOpEnums = {VK_ATTACHMENT_STORE_OP_STORE, VK_ATTACHMENT_STORE_OP_DONT_CARE, };
 const std::vector<VkPipelineBindPoint> AllVkPipelineBindPointEnums = {VK_PIPELINE_BIND_POINT_GRAPHICS, VK_PIPELINE_BIND_POINT_COMPUTE, VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, };
 const std::vector<VkCommandBufferLevel> AllVkCommandBufferLevelEnums = {VK_COMMAND_BUFFER_LEVEL_PRIMARY, VK_COMMAND_BUFFER_LEVEL_SECONDARY, };
-const std::vector<VkIndexType> AllVkIndexTypeEnums = {VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, VK_INDEX_TYPE_NONE_NV, };
+const std::vector<VkIndexType> AllVkIndexTypeEnums = {VK_INDEX_TYPE_UINT16, VK_INDEX_TYPE_UINT32, VK_INDEX_TYPE_NONE_NV, VK_INDEX_TYPE_UINT8_EXT, };
 const std::vector<VkSubpassContents> AllVkSubpassContentsEnums = {VK_SUBPASS_CONTENTS_INLINE, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, };
 const std::vector<VkObjectType> AllVkObjectTypeEnums = {VK_OBJECT_TYPE_UNKNOWN, VK_OBJECT_TYPE_INSTANCE, VK_OBJECT_TYPE_PHYSICAL_DEVICE, VK_OBJECT_TYPE_DEVICE, VK_OBJECT_TYPE_QUEUE, VK_OBJECT_TYPE_SEMAPHORE, VK_OBJECT_TYPE_COMMAND_BUFFER, VK_OBJECT_TYPE_FENCE, VK_OBJECT_TYPE_DEVICE_MEMORY, VK_OBJECT_TYPE_BUFFER, VK_OBJECT_TYPE_IMAGE, VK_OBJECT_TYPE_EVENT, VK_OBJECT_TYPE_QUERY_POOL, VK_OBJECT_TYPE_BUFFER_VIEW, VK_OBJECT_TYPE_IMAGE_VIEW, VK_OBJECT_TYPE_SHADER_MODULE, VK_OBJECT_TYPE_PIPELINE_CACHE, VK_OBJECT_TYPE_PIPELINE_LAYOUT, VK_OBJECT_TYPE_RENDER_PASS, VK_OBJECT_TYPE_PIPELINE, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, VK_OBJECT_TYPE_SAMPLER, VK_OBJECT_TYPE_DESCRIPTOR_POOL, VK_OBJECT_TYPE_DESCRIPTOR_SET, VK_OBJECT_TYPE_FRAMEBUFFER, VK_OBJECT_TYPE_COMMAND_POOL, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, VK_OBJECT_TYPE_SURFACE_KHR, VK_OBJECT_TYPE_SWAPCHAIN_KHR, VK_OBJECT_TYPE_DISPLAY_KHR, VK_OBJECT_TYPE_DISPLAY_MODE_KHR, VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT, VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR, VK_OBJECT_TYPE_OBJECT_TABLE_NVX, VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX, VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR, VK_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV, VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL, };
 const std::vector<VkVendorId> AllVkVendorIdEnums = {VK_VENDOR_ID_VIV, VK_VENDOR_ID_VSI, VK_VENDOR_ID_KAZAN, };
@@ -158,6 +159,8 @@ const std::vector<VkSamplerYcbcrModelConversionKHR> AllVkSamplerYcbcrModelConver
 const std::vector<VkSamplerYcbcrRangeKHR> AllVkSamplerYcbcrRangeKHREnums = {VK_SAMPLER_YCBCR_RANGE_ITU_FULL, VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR, VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR, };
 const std::vector<VkChromaLocationKHR> AllVkChromaLocationKHREnums = {VK_CHROMA_LOCATION_COSITED_EVEN, VK_CHROMA_LOCATION_MIDPOINT, VK_CHROMA_LOCATION_COSITED_EVEN_KHR, VK_CHROMA_LOCATION_MIDPOINT_KHR, };
 const std::vector<VkDriverIdKHR> AllVkDriverIdKHREnums = {VK_DRIVER_ID_AMD_PROPRIETARY_KHR, VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR, VK_DRIVER_ID_MESA_RADV_KHR, VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR, VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR, VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR, VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR, VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR, VK_DRIVER_ID_ARM_PROPRIETARY_KHR, VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR, VK_DRIVER_ID_GGP_PROPRIETARY_KHR, VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR, };
+const std::vector<VkShaderFloatControlsIndependenceKHR> AllVkShaderFloatControlsIndependenceKHREnums = {VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR, VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR, };
+const std::vector<VkPipelineExecutableStatisticFormatKHR> AllVkPipelineExecutableStatisticFormatKHREnums = {VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR, VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR, };
 const std::vector<VkDebugReportObjectTypeEXT> AllVkDebugReportObjectTypeEXTEnums = {VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, };
 const std::vector<VkRasterizationOrderAMD> AllVkRasterizationOrderAMDEnums = {VK_RASTERIZATION_ORDER_STRICT_AMD, VK_RASTERIZATION_ORDER_RELAXED_AMD, };
 const std::vector<VkShaderInfoTypeAMD> AllVkShaderInfoTypeAMDEnums = {VK_SHADER_INFO_TYPE_STATISTICS_AMD, VK_SHADER_INFO_TYPE_BINARY_AMD, VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD, };
@@ -176,9 +179,9 @@ const std::vector<VkCoverageModulationModeNV> AllVkCoverageModulationModeNVEnums
 const std::vector<VkValidationCacheHeaderVersionEXT> AllVkValidationCacheHeaderVersionEXTEnums = {VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT, };
 const std::vector<VkShadingRatePaletteEntryNV> AllVkShadingRatePaletteEntryNVEnums = {VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV, VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV, VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV, };
 const std::vector<VkCoarseSampleOrderTypeNV> AllVkCoarseSampleOrderTypeNVEnums = {VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV, VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV, VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV, VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV, };
+const std::vector<VkAccelerationStructureTypeNV> AllVkAccelerationStructureTypeNVEnums = {VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV, };
 const std::vector<VkRayTracingShaderGroupTypeNV> AllVkRayTracingShaderGroupTypeNVEnums = {VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV, VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV, VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV, };
 const std::vector<VkGeometryTypeNV> AllVkGeometryTypeNVEnums = {VK_GEOMETRY_TYPE_TRIANGLES_NV, VK_GEOMETRY_TYPE_AABBS_NV, };
-const std::vector<VkAccelerationStructureTypeNV> AllVkAccelerationStructureTypeNVEnums = {VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV, VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV, };
 const std::vector<VkCopyAccelerationStructureModeNV> AllVkCopyAccelerationStructureModeNVEnums = {VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV, VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV, };
 const std::vector<VkAccelerationStructureMemoryRequirementsTypeNV> AllVkAccelerationStructureMemoryRequirementsTypeNVEnums = {VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV, VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV, VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV, };
 const std::vector<VkQueueGlobalPriorityEXT> AllVkQueueGlobalPriorityEXTEnums = {VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT, VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT, VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT, VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT, };
@@ -189,7 +192,7 @@ const std::vector<VkQueryPoolSamplingModeINTEL> AllVkQueryPoolSamplingModeINTELE
 const std::vector<VkPerformanceOverrideTypeINTEL> AllVkPerformanceOverrideTypeINTELEnums = {VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL, VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL, };
 const std::vector<VkPerformanceParameterTypeINTEL> AllVkPerformanceParameterTypeINTELEnums = {VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL, VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL, };
 const std::vector<VkPerformanceValueTypeINTEL> AllVkPerformanceValueTypeINTELEnums = {VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL, VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL, VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL, VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL, VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL, };
-const std::vector<VkValidationFeatureEnableEXT> AllVkValidationFeatureEnableEXTEnums = {VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, };
+const std::vector<VkValidationFeatureEnableEXT> AllVkValidationFeatureEnableEXTEnums = {VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT, VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT, VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT, };
 const std::vector<VkValidationFeatureDisableEXT> AllVkValidationFeatureDisableEXTEnums = {VK_VALIDATION_FEATURE_DISABLE_ALL_EXT, VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT, VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT, VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT, VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT, VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT, VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT, };
 const std::vector<VkComponentTypeNV> AllVkComponentTypeNVEnums = {VK_COMPONENT_TYPE_FLOAT16_NV, VK_COMPONENT_TYPE_FLOAT32_NV, VK_COMPONENT_TYPE_FLOAT64_NV, VK_COMPONENT_TYPE_SINT8_NV, VK_COMPONENT_TYPE_SINT16_NV, VK_COMPONENT_TYPE_SINT32_NV, VK_COMPONENT_TYPE_SINT64_NV, VK_COMPONENT_TYPE_UINT8_NV, VK_COMPONENT_TYPE_UINT16_NV, VK_COMPONENT_TYPE_UINT32_NV, VK_COMPONENT_TYPE_UINT64_NV, };
 const std::vector<VkScopeNV> AllVkScopeNVEnums = {VK_SCOPE_DEVICE_NV, VK_SCOPE_WORKGROUP_NV, VK_SCOPE_SUBGROUP_NV, VK_SCOPE_QUEUE_FAMILY_NV, };
@@ -198,6 +201,8 @@ const std::vector<VkCoverageReductionModeNV> AllVkCoverageReductionModeNVEnums =
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 const std::vector<VkFullScreenExclusiveEXT> AllVkFullScreenExclusiveEXTEnums = {VK_FULL_SCREEN_EXCLUSIVE_DEFAULT_EXT, VK_FULL_SCREEN_EXCLUSIVE_ALLOWED_EXT, VK_FULL_SCREEN_EXCLUSIVE_DISALLOWED_EXT, VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, };
 #endif // VK_USE_PLATFORM_WIN32_KHR
+const std::vector<VkLineRasterizationModeEXT> AllVkLineRasterizationModeEXTEnums = {VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, };
+
 
 bool StatelessValidation::ValidatePnextStructContents(const char *api_name, const ParameterName &parameter_name, const VkBaseOutStructure* header) {
     bool skip = false;
@@ -218,7 +223,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkMemoryAllocateFlagsInfo structure members
         case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: {
             VkMemoryAllocateFlagsInfo *structure = (VkMemoryAllocateFlagsInfo *) header;
-            skip |= validate_flags("VkMemoryAllocateFlagsInfo", "flags", "VkMemoryAllocateFlagBits", AllVkMemoryAllocateFlagBits, structure->flags, false, false, "VUID-VkMemoryAllocateFlagsInfo-flags-parameter");
+            skip |= validate_flags("VkMemoryAllocateFlagsInfo", "flags", "VkMemoryAllocateFlagBits", AllVkMemoryAllocateFlagBits, structure->flags, kOptionalFlags, "VUID-VkMemoryAllocateFlagsInfo-flags-parameter");
         } break;
 
         // Validation code for VkDeviceGroupRenderPassBeginInfo structure members
@@ -394,7 +399,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             {
                 for (uint32_t aspectReferenceIndex = 0; aspectReferenceIndex < structure->aspectReferenceCount; ++aspectReferenceIndex)
                 {
-                    skip |= validate_flags("VkRenderPassInputAttachmentAspectCreateInfo", ParameterName("pAspectReferences[%i].aspectMask", ParameterName::IndexVector{ aspectReferenceIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, structure->pAspectReferences[aspectReferenceIndex].aspectMask, true, false, "VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask");
+                    skip |= validate_flags("VkRenderPassInputAttachmentAspectCreateInfo", ParameterName("pAspectReferences[%i].aspectMask", ParameterName::IndexVector{ aspectReferenceIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, structure->pAspectReferences[aspectReferenceIndex].aspectMask, kRequiredFlags, "VUID-VkInputAttachmentAspectReference-aspectMask-parameter", "VUID-VkInputAttachmentAspectReference-aspectMask-requiredbitmask");
                 }
             }
         } break;
@@ -402,7 +407,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkImageViewUsageCreateInfo structure members
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: {
             VkImageViewUsageCreateInfo *structure = (VkImageViewUsageCreateInfo *) header;
-            skip |= validate_flags("VkImageViewUsageCreateInfo", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, structure->usage, true, false, "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask");
+            skip |= validate_flags("VkImageViewUsageCreateInfo", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, structure->usage, kRequiredFlags, "VUID-VkImageViewUsageCreateInfo-usage-parameter", "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask");
         } break;
 
         // Validation code for VkPipelineTessellationDomainOriginStateCreateInfo structure members
@@ -460,13 +465,13 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkBindImagePlaneMemoryInfo structure members
         case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: {
             VkBindImagePlaneMemoryInfo *structure = (VkBindImagePlaneMemoryInfo *) header;
-            skip |= validate_flags("VkBindImagePlaneMemoryInfo", "planeAspect", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, structure->planeAspect, true, true, "VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter");
+            skip |= validate_flags("VkBindImagePlaneMemoryInfo", "planeAspect", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, structure->planeAspect, kRequiredSingleBit, "VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter", "VUID-VkBindImagePlaneMemoryInfo-planeAspect-parameter");
         } break;
 
         // Validation code for VkImagePlaneMemoryRequirementsInfo structure members
         case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: {
             VkImagePlaneMemoryRequirementsInfo *structure = (VkImagePlaneMemoryRequirementsInfo *) header;
-            skip |= validate_flags("VkImagePlaneMemoryRequirementsInfo", "planeAspect", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, structure->planeAspect, true, true, "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter");
+            skip |= validate_flags("VkImagePlaneMemoryRequirementsInfo", "planeAspect", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, structure->planeAspect, kRequiredSingleBit, "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter", "VUID-VkImagePlaneMemoryRequirementsInfo-planeAspect-parameter");
         } break;
 
         // Validation code for VkPhysicalDeviceSamplerYcbcrConversionFeatures structure members
@@ -478,37 +483,37 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkPhysicalDeviceExternalImageFormatInfo structure members
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: {
             VkPhysicalDeviceExternalImageFormatInfo *structure = (VkPhysicalDeviceExternalImageFormatInfo *) header;
-            skip |= validate_flags("VkPhysicalDeviceExternalImageFormatInfo", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, false, true, "VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter");
+            skip |= validate_flags("VkPhysicalDeviceExternalImageFormatInfo", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, kOptionalSingleBit, "VUID-VkPhysicalDeviceExternalImageFormatInfo-handleType-parameter");
         } break;
 
         // Validation code for VkExternalMemoryImageCreateInfo structure members
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: {
             VkExternalMemoryImageCreateInfo *structure = (VkExternalMemoryImageCreateInfo *) header;
-            skip |= validate_flags("VkExternalMemoryImageCreateInfo", "handleTypes", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleTypes, true, false, "VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask");
+            skip |= validate_flags("VkExternalMemoryImageCreateInfo", "handleTypes", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleTypes, kRequiredFlags, "VUID-VkExternalMemoryImageCreateInfo-handleTypes-parameter", "VUID-VkExternalMemoryImageCreateInfo-handleTypes-requiredbitmask");
         } break;
 
         // Validation code for VkExternalMemoryBufferCreateInfo structure members
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: {
             VkExternalMemoryBufferCreateInfo *structure = (VkExternalMemoryBufferCreateInfo *) header;
-            skip |= validate_flags("VkExternalMemoryBufferCreateInfo", "handleTypes", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleTypes, false, false, "VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter");
+            skip |= validate_flags("VkExternalMemoryBufferCreateInfo", "handleTypes", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleTypes, kOptionalFlags, "VUID-VkExternalMemoryBufferCreateInfo-handleTypes-parameter");
         } break;
 
         // Validation code for VkExportMemoryAllocateInfo structure members
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: {
             VkExportMemoryAllocateInfo *structure = (VkExportMemoryAllocateInfo *) header;
-            skip |= validate_flags("VkExportMemoryAllocateInfo", "handleTypes", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleTypes, false, false, "VUID-VkExportMemoryAllocateInfo-handleTypes-parameter");
+            skip |= validate_flags("VkExportMemoryAllocateInfo", "handleTypes", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleTypes, kOptionalFlags, "VUID-VkExportMemoryAllocateInfo-handleTypes-parameter");
         } break;
 
         // Validation code for VkExportFenceCreateInfo structure members
         case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: {
             VkExportFenceCreateInfo *structure = (VkExportFenceCreateInfo *) header;
-            skip |= validate_flags("VkExportFenceCreateInfo", "handleTypes", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, structure->handleTypes, false, false, "VUID-VkExportFenceCreateInfo-handleTypes-parameter");
+            skip |= validate_flags("VkExportFenceCreateInfo", "handleTypes", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, structure->handleTypes, kOptionalFlags, "VUID-VkExportFenceCreateInfo-handleTypes-parameter");
         } break;
 
         // Validation code for VkExportSemaphoreCreateInfo structure members
         case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: {
             VkExportSemaphoreCreateInfo *structure = (VkExportSemaphoreCreateInfo *) header;
-            skip |= validate_flags("VkExportSemaphoreCreateInfo", "handleTypes", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, structure->handleTypes, false, false, "VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter");
+            skip |= validate_flags("VkExportSemaphoreCreateInfo", "handleTypes", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, structure->handleTypes, kOptionalFlags, "VUID-VkExportSemaphoreCreateInfo-handleTypes-parameter");
         } break;
 
         // Validation code for VkPhysicalDeviceShaderDrawParametersFeatures structure members
@@ -528,13 +533,13 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             VkDeviceGroupPresentInfoKHR *structure = (VkDeviceGroupPresentInfoKHR *) header;
             skip |= validate_array("VkDeviceGroupPresentInfoKHR", "swapchainCount", "pDeviceMasks", structure->swapchainCount, &structure->pDeviceMasks, false, true, kVUIDUndefined, "VUID-VkDeviceGroupPresentInfoKHR-pDeviceMasks-parameter");
 
-            skip |= validate_flags("VkDeviceGroupPresentInfoKHR", "mode", "VkDeviceGroupPresentModeFlagBitsKHR", AllVkDeviceGroupPresentModeFlagBitsKHR, structure->mode, true, true, "VUID-VkDeviceGroupPresentInfoKHR-mode-parameter");
+            skip |= validate_flags("VkDeviceGroupPresentInfoKHR", "mode", "VkDeviceGroupPresentModeFlagBitsKHR", AllVkDeviceGroupPresentModeFlagBitsKHR, structure->mode, kRequiredSingleBit, "VUID-VkDeviceGroupPresentInfoKHR-mode-parameter", "VUID-VkDeviceGroupPresentInfoKHR-mode-parameter");
         } break;
 
         // Validation code for VkDeviceGroupSwapchainCreateInfoKHR structure members
         case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: {
             VkDeviceGroupSwapchainCreateInfoKHR *structure = (VkDeviceGroupSwapchainCreateInfoKHR *) header;
-            skip |= validate_flags("VkDeviceGroupSwapchainCreateInfoKHR", "modes", "VkDeviceGroupPresentModeFlagBitsKHR", AllVkDeviceGroupPresentModeFlagBitsKHR, structure->modes, true, false, "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask");
+            skip |= validate_flags("VkDeviceGroupSwapchainCreateInfoKHR", "modes", "VkDeviceGroupPresentModeFlagBitsKHR", AllVkDeviceGroupPresentModeFlagBitsKHR, structure->modes, kRequiredFlags, "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-parameter", "VUID-VkDeviceGroupSwapchainCreateInfoKHR-modes-requiredbitmask");
         } break;
 
         // Validation code for VkDisplayPresentInfoKHR structure members
@@ -547,14 +552,14 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkImportMemoryWin32HandleInfoKHR structure members
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: {
             VkImportMemoryWin32HandleInfoKHR *structure = (VkImportMemoryWin32HandleInfoKHR *) header;
-            skip |= validate_flags("VkImportMemoryWin32HandleInfoKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, false, true, "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter");
+            skip |= validate_flags("VkImportMemoryWin32HandleInfoKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, kOptionalSingleBit, "VUID-VkImportMemoryWin32HandleInfoKHR-handleType-parameter");
         } break;
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
         // Validation code for VkImportMemoryFdInfoKHR structure members
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: {
             VkImportMemoryFdInfoKHR *structure = (VkImportMemoryFdInfoKHR *) header;
-            skip |= validate_flags("VkImportMemoryFdInfoKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, false, true, "VUID-VkImportMemoryFdInfoKHR-handleType-parameter");
+            skip |= validate_flags("VkImportMemoryFdInfoKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, kOptionalSingleBit, "VUID-VkImportMemoryFdInfoKHR-handleType-parameter");
         } break;
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
@@ -573,12 +578,12 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         } break;
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
-        // Validation code for VkPhysicalDeviceFloat16Int8FeaturesKHR structure members
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: {
-            VkPhysicalDeviceFloat16Int8FeaturesKHR *structure = (VkPhysicalDeviceFloat16Int8FeaturesKHR *) header;
-            skip |= validate_bool32("VkPhysicalDeviceFloat16Int8FeaturesKHR", "shaderFloat16", structure->shaderFloat16);
+        // Validation code for VkPhysicalDeviceShaderFloat16Int8FeaturesKHR structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: {
+            VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *structure = (VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *) header;
+            skip |= validate_bool32("VkPhysicalDeviceShaderFloat16Int8FeaturesKHR", "shaderFloat16", structure->shaderFloat16);
 
-            skip |= validate_bool32("VkPhysicalDeviceFloat16Int8FeaturesKHR", "shaderInt8", structure->shaderInt8);
+            skip |= validate_bool32("VkPhysicalDeviceShaderFloat16Int8FeaturesKHR", "shaderInt8", structure->shaderInt8);
         } break;
 
         // Validation code for VkPresentRegionsKHR structure members
@@ -615,9 +620,9 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             {
                 for (uint32_t attachmentImageInfoIndex = 0; attachmentImageInfoIndex < structure->attachmentImageInfoCount; ++attachmentImageInfoIndex)
                 {
-                    skip |= validate_flags("VkFramebufferAttachmentsCreateInfoKHR", ParameterName("pAttachmentImageInfos[%i].flags", ParameterName::IndexVector{ attachmentImageInfoIndex }), "VkImageCreateFlagBits", AllVkImageCreateFlagBits, structure->pAttachmentImageInfos[attachmentImageInfoIndex].flags, false, false, "VUID-VkFramebufferAttachmentImageInfoKHR-flags-parameter");
+                    skip |= validate_flags("VkFramebufferAttachmentsCreateInfoKHR", ParameterName("pAttachmentImageInfos[%i].flags", ParameterName::IndexVector{ attachmentImageInfoIndex }), "VkImageCreateFlagBits", AllVkImageCreateFlagBits, structure->pAttachmentImageInfos[attachmentImageInfoIndex].flags, kOptionalFlags, "VUID-VkFramebufferAttachmentImageInfoKHR-flags-parameter");
 
-                    skip |= validate_flags("VkFramebufferAttachmentsCreateInfoKHR", ParameterName("pAttachmentImageInfos[%i].usage", ParameterName::IndexVector{ attachmentImageInfoIndex }), "VkImageUsageFlagBits", AllVkImageUsageFlagBits, structure->pAttachmentImageInfos[attachmentImageInfoIndex].usage, true, false, "VUID-VkFramebufferAttachmentImageInfoKHR-usage-requiredbitmask");
+                    skip |= validate_flags("VkFramebufferAttachmentsCreateInfoKHR", ParameterName("pAttachmentImageInfos[%i].usage", ParameterName::IndexVector{ attachmentImageInfoIndex }), "VkImageUsageFlagBits", AllVkImageUsageFlagBits, structure->pAttachmentImageInfos[attachmentImageInfoIndex].usage, kRequiredFlags, "VUID-VkFramebufferAttachmentImageInfoKHR-usage-parameter", "VUID-VkFramebufferAttachmentImageInfoKHR-usage-requiredbitmask");
 
                     skip |= validate_ranged_enum_array("VkFramebufferAttachmentsCreateInfoKHR", ParameterName("pAttachmentImageInfos[%i].viewFormatCount", ParameterName::IndexVector{ attachmentImageInfoIndex }), ParameterName("pAttachmentImageInfos[%i].pViewFormats", ParameterName::IndexVector{ attachmentImageInfoIndex }), "VkFormat", AllVkFormatEnums, structure->pAttachmentImageInfos[attachmentImageInfoIndex].viewFormatCount, structure->pAttachmentImageInfos[attachmentImageInfoIndex].pViewFormats, false, true);
                 }
@@ -657,9 +662,9 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkSubpassDescriptionDepthStencilResolveKHR structure members
         case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: {
             VkSubpassDescriptionDepthStencilResolveKHR *structure = (VkSubpassDescriptionDepthStencilResolveKHR *) header;
-            skip |= validate_flags("VkSubpassDescriptionDepthStencilResolveKHR", "depthResolveMode", "VkResolveModeFlagBitsKHR", AllVkResolveModeFlagBitsKHR, structure->depthResolveMode, true, true, "VUID-VkSubpassDescriptionDepthStencilResolveKHR-depthResolveMode-parameter");
+            skip |= validate_flags("VkSubpassDescriptionDepthStencilResolveKHR", "depthResolveMode", "VkResolveModeFlagBitsKHR", AllVkResolveModeFlagBitsKHR, structure->depthResolveMode, kRequiredSingleBit, "VUID-VkSubpassDescriptionDepthStencilResolveKHR-depthResolveMode-parameter", "VUID-VkSubpassDescriptionDepthStencilResolveKHR-depthResolveMode-parameter");
 
-            skip |= validate_flags("VkSubpassDescriptionDepthStencilResolveKHR", "stencilResolveMode", "VkResolveModeFlagBitsKHR", AllVkResolveModeFlagBitsKHR, structure->stencilResolveMode, true, true, "VUID-VkSubpassDescriptionDepthStencilResolveKHR-stencilResolveMode-parameter");
+            skip |= validate_flags("VkSubpassDescriptionDepthStencilResolveKHR", "stencilResolveMode", "VkResolveModeFlagBitsKHR", AllVkResolveModeFlagBitsKHR, structure->stencilResolveMode, kRequiredSingleBit, "VUID-VkSubpassDescriptionDepthStencilResolveKHR-stencilResolveMode-parameter", "VUID-VkSubpassDescriptionDepthStencilResolveKHR-stencilResolveMode-parameter");
 
             skip |= validate_struct_type("VkSubpassDescriptionDepthStencilResolveKHR", "pDepthStencilResolveAttachment", "VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR", structure->pDepthStencilResolveAttachment, VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR, false, "VUID-VkSubpassDescriptionDepthStencilResolveKHR-pDepthStencilResolveAttachment-parameter", "VUID-VkAttachmentReference2KHR-sType-sType");
 
@@ -691,10 +696,16 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             skip |= validate_bool32("VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR", "uniformBufferStandardLayout", structure->uniformBufferStandardLayout);
         } break;
 
+        // Validation code for VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
+            VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *structure = (VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *) header;
+            skip |= validate_bool32("VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR", "pipelineExecutableInfo", structure->pipelineExecutableInfo);
+        } break;
+
         // Validation code for VkDebugReportCallbackCreateInfoEXT structure members
         case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: {
             VkDebugReportCallbackCreateInfoEXT *structure = (VkDebugReportCallbackCreateInfoEXT *) header;
-            skip |= validate_flags("VkDebugReportCallbackCreateInfoEXT", "flags", "VkDebugReportFlagBitsEXT", AllVkDebugReportFlagBitsEXT, structure->flags, false, false, "VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter");
+            skip |= validate_flags("VkDebugReportCallbackCreateInfoEXT", "flags", "VkDebugReportFlagBitsEXT", AllVkDebugReportFlagBitsEXT, structure->flags, kOptionalFlags, "VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter");
 
             skip |= validate_required_pointer("VkDebugReportCallbackCreateInfoEXT", "pfnCallback", reinterpret_cast<const void*>(structure->pfnCallback), "VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-parameter");
         } break;
@@ -740,20 +751,20 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkExternalMemoryImageCreateInfoNV structure members
         case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: {
             VkExternalMemoryImageCreateInfoNV *structure = (VkExternalMemoryImageCreateInfoNV *) header;
-            skip |= validate_flags("VkExternalMemoryImageCreateInfoNV", "handleTypes", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, structure->handleTypes, false, false, "VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter");
+            skip |= validate_flags("VkExternalMemoryImageCreateInfoNV", "handleTypes", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, structure->handleTypes, kOptionalFlags, "VUID-VkExternalMemoryImageCreateInfoNV-handleTypes-parameter");
         } break;
 
         // Validation code for VkExportMemoryAllocateInfoNV structure members
         case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: {
             VkExportMemoryAllocateInfoNV *structure = (VkExportMemoryAllocateInfoNV *) header;
-            skip |= validate_flags("VkExportMemoryAllocateInfoNV", "handleTypes", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, structure->handleTypes, false, false, "VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter");
+            skip |= validate_flags("VkExportMemoryAllocateInfoNV", "handleTypes", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, structure->handleTypes, kOptionalFlags, "VUID-VkExportMemoryAllocateInfoNV-handleTypes-parameter");
         } break;
 
 #ifdef VK_USE_PLATFORM_WIN32_KHR
         // Validation code for VkImportMemoryWin32HandleInfoNV structure members
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: {
             VkImportMemoryWin32HandleInfoNV *structure = (VkImportMemoryWin32HandleInfoNV *) header;
-            skip |= validate_flags("VkImportMemoryWin32HandleInfoNV", "handleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, structure->handleType, false, false, "VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter");
+            skip |= validate_flags("VkImportMemoryWin32HandleInfoNV", "handleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, structure->handleType, kOptionalFlags, "VUID-VkImportMemoryWin32HandleInfoNV-handleType-parameter");
         } break;
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -779,6 +790,12 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             skip |= validate_ranged_enum_array("VkValidationFlagsEXT", "disabledValidationCheckCount", "pDisabledValidationChecks", "VkValidationCheckEXT", AllVkValidationCheckEXTEnums, structure->disabledValidationCheckCount, structure->pDisabledValidationChecks, true, true);
         } break;
 
+        // Validation code for VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: {
+            VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *structure = (VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *) header;
+            skip |= validate_bool32("VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT", "textureCompressionASTC_HDR", structure->textureCompressionASTC_HDR);
+        } break;
+
         // Validation code for VkImageViewASTCDecodeModeEXT structure members
         case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: {
             VkImageViewASTCDecodeModeEXT *structure = (VkImageViewASTCDecodeModeEXT *) header;
@@ -814,7 +831,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkSwapchainCounterCreateInfoEXT structure members
         case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: {
             VkSwapchainCounterCreateInfoEXT *structure = (VkSwapchainCounterCreateInfoEXT *) header;
-            skip |= validate_flags("VkSwapchainCounterCreateInfoEXT", "surfaceCounters", "VkSurfaceCounterFlagBitsEXT", AllVkSurfaceCounterFlagBitsEXT, structure->surfaceCounters, false, false, "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter");
+            skip |= validate_flags("VkSwapchainCounterCreateInfoEXT", "surfaceCounters", "VkSurfaceCounterFlagBitsEXT", AllVkSurfaceCounterFlagBitsEXT, structure->surfaceCounters, kOptionalFlags, "VUID-VkSwapchainCounterCreateInfoEXT-surfaceCounters-parameter");
         } break;
 
         // Validation code for VkPresentTimesInfoGOOGLE structure members
@@ -887,9 +904,9 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             VkDebugUtilsMessengerCreateInfoEXT *structure = (VkDebugUtilsMessengerCreateInfoEXT *) header;
             skip |= validate_reserved_flags("VkDebugUtilsMessengerCreateInfoEXT", "flags", structure->flags, "VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask");
 
-            skip |= validate_flags("VkDebugUtilsMessengerCreateInfoEXT", "messageSeverity", "VkDebugUtilsMessageSeverityFlagBitsEXT", AllVkDebugUtilsMessageSeverityFlagBitsEXT, structure->messageSeverity, true, false, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask");
+            skip |= validate_flags("VkDebugUtilsMessengerCreateInfoEXT", "messageSeverity", "VkDebugUtilsMessageSeverityFlagBitsEXT", AllVkDebugUtilsMessageSeverityFlagBitsEXT, structure->messageSeverity, kRequiredFlags, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter", "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask");
 
-            skip |= validate_flags("VkDebugUtilsMessengerCreateInfoEXT", "messageType", "VkDebugUtilsMessageTypeFlagBitsEXT", AllVkDebugUtilsMessageTypeFlagBitsEXT, structure->messageType, true, false, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask");
+            skip |= validate_flags("VkDebugUtilsMessengerCreateInfoEXT", "messageType", "VkDebugUtilsMessageTypeFlagBitsEXT", AllVkDebugUtilsMessageTypeFlagBitsEXT, structure->messageType, kRequiredFlags, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter", "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask");
 
             skip |= validate_required_pointer("VkDebugUtilsMessengerCreateInfoEXT", "pfnUserCallback", reinterpret_cast<const void*>(structure->pfnUserCallback), "VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-parameter");
         } break;
@@ -925,7 +942,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkSampleLocationsInfoEXT structure members
         case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: {
             VkSampleLocationsInfoEXT *structure = (VkSampleLocationsInfoEXT *) header;
-            skip |= validate_flags("VkSampleLocationsInfoEXT", "sampleLocationsPerPixel", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->sampleLocationsPerPixel, false, true, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
+            skip |= validate_flags("VkSampleLocationsInfoEXT", "sampleLocationsPerPixel", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->sampleLocationsPerPixel, kOptionalSingleBit, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
 
             skip |= validate_array("VkSampleLocationsInfoEXT", "sampleLocationsCount", "pSampleLocations", structure->sampleLocationsCount, &structure->pSampleLocations, false, true, kVUIDUndefined, "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter");
 
@@ -948,7 +965,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
                 {
                     skip |= validate_struct_type("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pAttachmentInitialSampleLocations[%i].sampleLocationsInfo", ParameterName::IndexVector{ attachmentInitialSampleLocationsIndex }), "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", &(structure->pAttachmentInitialSampleLocations[attachmentInitialSampleLocationsIndex].sampleLocationsInfo), VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, false, kVUIDUndefined, "VUID-VkSampleLocationsInfoEXT-sType-sType");
 
-                    skip |= validate_flags("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pAttachmentInitialSampleLocations[%i].sampleLocationsInfo.sampleLocationsPerPixel", ParameterName::IndexVector{ attachmentInitialSampleLocationsIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->pAttachmentInitialSampleLocations[attachmentInitialSampleLocationsIndex].sampleLocationsInfo.sampleLocationsPerPixel, false, true, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
+                    skip |= validate_flags("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pAttachmentInitialSampleLocations[%i].sampleLocationsInfo.sampleLocationsPerPixel", ParameterName::IndexVector{ attachmentInitialSampleLocationsIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->pAttachmentInitialSampleLocations[attachmentInitialSampleLocationsIndex].sampleLocationsInfo.sampleLocationsPerPixel, kOptionalSingleBit, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
 
                     skip |= validate_array("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pAttachmentInitialSampleLocations[%i].sampleLocationsInfo.sampleLocationsCount", ParameterName::IndexVector{ attachmentInitialSampleLocationsIndex }), ParameterName("pAttachmentInitialSampleLocations[%i].sampleLocationsInfo.pSampleLocations", ParameterName::IndexVector{ attachmentInitialSampleLocationsIndex }), structure->pAttachmentInitialSampleLocations[attachmentInitialSampleLocationsIndex].sampleLocationsInfo.sampleLocationsCount, &structure->pAttachmentInitialSampleLocations[attachmentInitialSampleLocationsIndex].sampleLocationsInfo.pSampleLocations, false, true, kVUIDUndefined, "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter");
 
@@ -969,7 +986,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
                 {
                     skip |= validate_struct_type("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pPostSubpassSampleLocations[%i].sampleLocationsInfo", ParameterName::IndexVector{ postSubpassSampleLocationsIndex }), "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", &(structure->pPostSubpassSampleLocations[postSubpassSampleLocationsIndex].sampleLocationsInfo), VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, false, kVUIDUndefined, "VUID-VkSampleLocationsInfoEXT-sType-sType");
 
-                    skip |= validate_flags("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pPostSubpassSampleLocations[%i].sampleLocationsInfo.sampleLocationsPerPixel", ParameterName::IndexVector{ postSubpassSampleLocationsIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->pPostSubpassSampleLocations[postSubpassSampleLocationsIndex].sampleLocationsInfo.sampleLocationsPerPixel, false, true, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
+                    skip |= validate_flags("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pPostSubpassSampleLocations[%i].sampleLocationsInfo.sampleLocationsPerPixel", ParameterName::IndexVector{ postSubpassSampleLocationsIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->pPostSubpassSampleLocations[postSubpassSampleLocationsIndex].sampleLocationsInfo.sampleLocationsPerPixel, kOptionalSingleBit, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
 
                     skip |= validate_array("VkRenderPassSampleLocationsBeginInfoEXT", ParameterName("pPostSubpassSampleLocations[%i].sampleLocationsInfo.sampleLocationsCount", ParameterName::IndexVector{ postSubpassSampleLocationsIndex }), ParameterName("pPostSubpassSampleLocations[%i].sampleLocationsInfo.pSampleLocations", ParameterName::IndexVector{ postSubpassSampleLocationsIndex }), structure->pPostSubpassSampleLocations[postSubpassSampleLocationsIndex].sampleLocationsInfo.sampleLocationsCount, &structure->pPostSubpassSampleLocations[postSubpassSampleLocationsIndex].sampleLocationsInfo.pSampleLocations, false, true, kVUIDUndefined, "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter");
 
@@ -990,7 +1007,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
 
             skip |= validate_struct_type("VkPipelineSampleLocationsStateCreateInfoEXT", "sampleLocationsInfo", "VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT", &(structure->sampleLocationsInfo), VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT, false, kVUIDUndefined, "VUID-VkSampleLocationsInfoEXT-sType-sType");
 
-            skip |= validate_flags("VkPipelineSampleLocationsStateCreateInfoEXT", "sampleLocationsInfo.sampleLocationsPerPixel", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->sampleLocationsInfo.sampleLocationsPerPixel, false, true, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
+            skip |= validate_flags("VkPipelineSampleLocationsStateCreateInfoEXT", "sampleLocationsInfo.sampleLocationsPerPixel", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, structure->sampleLocationsInfo.sampleLocationsPerPixel, kOptionalSingleBit, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
 
             skip |= validate_array("VkPipelineSampleLocationsStateCreateInfoEXT", "sampleLocationsInfo.sampleLocationsCount", "sampleLocationsInfo.pSampleLocations", structure->sampleLocationsInfo.sampleLocationsCount, &structure->sampleLocationsInfo.pSampleLocations, false, true, kVUIDUndefined, "VUID-VkSampleLocationsInfoEXT-pSampleLocations-parameter");
 
@@ -1209,11 +1226,17 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkImportMemoryHostPointerInfoEXT structure members
         case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: {
             VkImportMemoryHostPointerInfoEXT *structure = (VkImportMemoryHostPointerInfoEXT *) header;
-            skip |= validate_flags("VkImportMemoryHostPointerInfoEXT", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, true, true, "VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter");
+            skip |= validate_flags("VkImportMemoryHostPointerInfoEXT", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, structure->handleType, kRequiredSingleBit, "VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter", "VUID-VkImportMemoryHostPointerInfoEXT-handleType-parameter");
 
             skip |= validate_required_pointer("VkImportMemoryHostPointerInfoEXT", "pHostPointer", structure->pHostPointer, kVUIDUndefined);
         } break;
 
+        // Validation code for VkPipelineCompilerControlCreateInfoAMD structure members
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: {
+            VkPipelineCompilerControlCreateInfoAMD *structure = (VkPipelineCompilerControlCreateInfoAMD *) header;
+            skip |= validate_reserved_flags("VkPipelineCompilerControlCreateInfoAMD", "compilerControlFlags", structure->compilerControlFlags, "VUID-VkPipelineCompilerControlCreateInfoAMD-compilerControlFlags-zerobitmask");
+        } break;
+
         // Validation code for VkDeviceMemoryOverallocationCreateInfoAMD structure members
         case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: {
             VkDeviceMemoryOverallocationCreateInfoAMD *structure = (VkDeviceMemoryOverallocationCreateInfoAMD *) header;
@@ -1305,10 +1328,10 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             skip |= validate_bool32("VkPhysicalDeviceExclusiveScissorFeaturesNV", "exclusiveScissor", structure->exclusiveScissor);
         } break;
 
-        // Validation code for VkPhysicalDeviceShaderIntegerFunctions2INTEL structure members
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL: {
-            VkPhysicalDeviceShaderIntegerFunctions2INTEL *structure = (VkPhysicalDeviceShaderIntegerFunctions2INTEL *) header;
-            skip |= validate_bool32("VkPhysicalDeviceShaderIntegerFunctions2INTEL", "shaderIntegerFunctions2", structure->shaderIntegerFunctions2);
+        // Validation code for VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+            VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *structure = (VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *) header;
+            skip |= validate_bool32("VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL", "shaderIntegerFunctions2", structure->shaderIntegerFunctions2);
         } break;
 
         // Validation code for VkSwapchainDisplayNativeHdrCreateInfoAMD structure members
@@ -1329,6 +1352,20 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
             skip |= validate_bool32("VkPhysicalDeviceScalarBlockLayoutFeaturesEXT", "scalarBlockLayout", structure->scalarBlockLayout);
         } break;
 
+        // Validation code for VkPhysicalDeviceSubgroupSizeControlFeaturesEXT structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: {
+            VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *structure = (VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *) header;
+            skip |= validate_bool32("VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", "subgroupSizeControl", structure->subgroupSizeControl);
+
+            skip |= validate_bool32("VkPhysicalDeviceSubgroupSizeControlFeaturesEXT", "computeFullSubgroups", structure->computeFullSubgroups);
+        } break;
+
+        // Validation code for VkPhysicalDeviceCoherentMemoryFeaturesAMD structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: {
+            VkPhysicalDeviceCoherentMemoryFeaturesAMD *structure = (VkPhysicalDeviceCoherentMemoryFeaturesAMD *) header;
+            skip |= validate_bool32("VkPhysicalDeviceCoherentMemoryFeaturesAMD", "deviceCoherentMemory", structure->deviceCoherentMemory);
+        } break;
+
         // Validation code for VkPhysicalDeviceMemoryPriorityFeaturesEXT structure members
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: {
             VkPhysicalDeviceMemoryPriorityFeaturesEXT *structure = (VkPhysicalDeviceMemoryPriorityFeaturesEXT *) header;
@@ -1354,7 +1391,7 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         // Validation code for VkImageStencilUsageCreateInfoEXT structure members
         case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: {
             VkImageStencilUsageCreateInfoEXT *structure = (VkImageStencilUsageCreateInfoEXT *) header;
-            skip |= validate_flags("VkImageStencilUsageCreateInfoEXT", "stencilUsage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, structure->stencilUsage, true, false, "VUID-VkImageStencilUsageCreateInfoEXT-stencilUsage-requiredbitmask");
+            skip |= validate_flags("VkImageStencilUsageCreateInfoEXT", "stencilUsage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, structure->stencilUsage, kRequiredFlags, "VUID-VkImageStencilUsageCreateInfoEXT-stencilUsage-parameter", "VUID-VkImageStencilUsageCreateInfoEXT-stencilUsage-requiredbitmask");
         } break;
 
         // Validation code for VkValidationFeaturesEXT structure members
@@ -1419,12 +1456,42 @@ bool StatelessValidation::ValidatePnextStructContents(const char *api_name, cons
         } break;
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
+        // Validation code for VkPhysicalDeviceLineRasterizationFeaturesEXT structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: {
+            VkPhysicalDeviceLineRasterizationFeaturesEXT *structure = (VkPhysicalDeviceLineRasterizationFeaturesEXT *) header;
+            skip |= validate_bool32("VkPhysicalDeviceLineRasterizationFeaturesEXT", "rectangularLines", structure->rectangularLines);
+
+            skip |= validate_bool32("VkPhysicalDeviceLineRasterizationFeaturesEXT", "bresenhamLines", structure->bresenhamLines);
+
+            skip |= validate_bool32("VkPhysicalDeviceLineRasterizationFeaturesEXT", "smoothLines", structure->smoothLines);
+
+            skip |= validate_bool32("VkPhysicalDeviceLineRasterizationFeaturesEXT", "stippledRectangularLines", structure->stippledRectangularLines);
+
+            skip |= validate_bool32("VkPhysicalDeviceLineRasterizationFeaturesEXT", "stippledBresenhamLines", structure->stippledBresenhamLines);
+
+            skip |= validate_bool32("VkPhysicalDeviceLineRasterizationFeaturesEXT", "stippledSmoothLines", structure->stippledSmoothLines);
+        } break;
+
+        // Validation code for VkPipelineRasterizationLineStateCreateInfoEXT structure members
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: {
+            VkPipelineRasterizationLineStateCreateInfoEXT *structure = (VkPipelineRasterizationLineStateCreateInfoEXT *) header;
+            skip |= validate_ranged_enum("VkPipelineRasterizationLineStateCreateInfoEXT", "lineRasterizationMode", "VkLineRasterizationModeEXT", AllVkLineRasterizationModeEXTEnums, structure->lineRasterizationMode, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter");
+
+            skip |= validate_bool32("VkPipelineRasterizationLineStateCreateInfoEXT", "stippledLineEnable", structure->stippledLineEnable);
+        } break;
+
         // Validation code for VkPhysicalDeviceHostQueryResetFeaturesEXT structure members
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: {
             VkPhysicalDeviceHostQueryResetFeaturesEXT *structure = (VkPhysicalDeviceHostQueryResetFeaturesEXT *) header;
             skip |= validate_bool32("VkPhysicalDeviceHostQueryResetFeaturesEXT", "hostQueryReset", structure->hostQueryReset);
         } break;
 
+        // Validation code for VkPhysicalDeviceIndexTypeUint8FeaturesEXT structure members
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
+            VkPhysicalDeviceIndexTypeUint8FeaturesEXT *structure = (VkPhysicalDeviceIndexTypeUint8FeaturesEXT *) header;
+            skip |= validate_bool32("VkPhysicalDeviceIndexTypeUint8FeaturesEXT", "indexTypeUint8", structure->indexTypeUint8);
+        } break;
+
         // Validation code for VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT structure members
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: {
             VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *structure = (VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *) header;
@@ -1496,7 +1563,7 @@ bool StatelessValidation::PreCallValidateCreateInstance(
         }
     }
     skip |= validate_required_pointer("vkCreateInstance", "pInstance", pInstance, "VUID-vkCreateInstance-pInstance-parameter");
-    skip |= manual_PreCallValidateCreateInstance(pCreateInfo, pAllocator, pInstance);
+    if (!skip) skip |= manual_PreCallValidateCreateInstance(pCreateInfo, pAllocator, pInstance);
     return skip;
 }
 
@@ -1570,8 +1637,8 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties(
     skip |= validate_ranged_enum("vkGetPhysicalDeviceImageFormatProperties", "format", "VkFormat", AllVkFormatEnums, format, "VUID-vkGetPhysicalDeviceImageFormatProperties-format-parameter");
     skip |= validate_ranged_enum("vkGetPhysicalDeviceImageFormatProperties", "type", "VkImageType", AllVkImageTypeEnums, type, "VUID-vkGetPhysicalDeviceImageFormatProperties-type-parameter");
     skip |= validate_ranged_enum("vkGetPhysicalDeviceImageFormatProperties", "tiling", "VkImageTiling", AllVkImageTilingEnums, tiling, "VUID-vkGetPhysicalDeviceImageFormatProperties-tiling-parameter");
-    skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true, false, "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask");
-    skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, false, false, "VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter");
+    skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, kRequiredFlags, "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-parameter", "VUID-vkGetPhysicalDeviceImageFormatProperties-usage-requiredbitmask");
+    skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, kOptionalFlags, "VUID-vkGetPhysicalDeviceImageFormatProperties-flags-parameter");
     skip |= validate_required_pointer("vkGetPhysicalDeviceImageFormatProperties", "pImageFormatProperties", pImageFormatProperties, "VUID-vkGetPhysicalDeviceImageFormatProperties-pImageFormatProperties-parameter");
     if (pImageFormatProperties != NULL)
     {
@@ -1629,9 +1696,9 @@ bool StatelessValidation::PreCallValidateCreateDevice(
     skip |= validate_struct_type("vkCreateDevice", "pCreateInfo", "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO", pCreateInfo, VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, true, "VUID-vkCreateDevice-pCreateInfo-parameter", "VUID-VkDeviceCreateInfo-sType-sType");
     if (pCreateInfo != NULL)
     {
-        const VkStructureType allowed_structs_VkDeviceCreateInfo[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT };
+        const VkStructureType allowed_structs_VkDeviceCreateInfo[] = { VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT };
 
-        skip |= validate_struct_pnext("vkCreateDevice", "pCreateInfo->pNext", "VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFloat16Int8FeaturesKHR, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2INTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkDeviceCreateInfo), allowed_structs_VkDeviceCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkDeviceCreateInfo-pNext-pNext");
+        skip |= validate_struct_pnext("vkCreateDevice", "pCreateInfo->pNext", "VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8FeaturesKHR, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, VkPhysicalDeviceYcbcrImageArraysFeaturesEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkDeviceCreateInfo), allowed_structs_VkDeviceCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkDeviceCreateInfo-pNext-pNext");
 
         skip |= validate_reserved_flags("vkCreateDevice", "pCreateInfo->flags", pCreateInfo->flags, "VUID-VkDeviceCreateInfo-flags-zerobitmask");
 
@@ -1645,7 +1712,7 @@ bool StatelessValidation::PreCallValidateCreateDevice(
 
                 skip |= validate_struct_pnext("vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].pNext", ParameterName::IndexVector{ queueCreateInfoIndex }), "VkDeviceQueueGlobalPriorityCreateInfoEXT", pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkDeviceQueueCreateInfo), allowed_structs_VkDeviceQueueCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkDeviceQueueCreateInfo-pNext-pNext");
 
-                skip |= validate_flags("vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].flags", ParameterName::IndexVector{ queueCreateInfoIndex }), "VkDeviceQueueCreateFlagBits", AllVkDeviceQueueCreateFlagBits, pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].flags, false, false, "VUID-VkDeviceQueueCreateInfo-flags-parameter");
+                skip |= validate_flags("vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].flags", ParameterName::IndexVector{ queueCreateInfoIndex }), "VkDeviceQueueCreateFlagBits", AllVkDeviceQueueCreateFlagBits, pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].flags, kOptionalFlags, "VUID-VkDeviceQueueCreateInfo-flags-parameter");
 
                 skip |= validate_array("vkCreateDevice", ParameterName("pCreateInfo->pQueueCreateInfos[%i].queueCount", ParameterName::IndexVector{ queueCreateInfoIndex }), ParameterName("pCreateInfo->pQueueCreateInfos[%i].pQueuePriorities", ParameterName::IndexVector{ queueCreateInfoIndex }), pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].queueCount, &pCreateInfo->pQueueCreateInfos[queueCreateInfoIndex].pQueuePriorities, true, true, "VUID-VkDeviceQueueCreateInfo-queueCount-arraylength", "VUID-VkDeviceQueueCreateInfo-pQueuePriorities-parameter");
             }
@@ -1789,7 +1856,7 @@ bool StatelessValidation::PreCallValidateCreateDevice(
         }
     }
     skip |= validate_required_pointer("vkCreateDevice", "pDevice", pDevice, "VUID-vkCreateDevice-pDevice-parameter");
-    skip |= manual_PreCallValidateCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
+    if (!skip) skip |= manual_PreCallValidateCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
     return skip;
 }
 
@@ -1905,7 +1972,7 @@ bool StatelessValidation::PreCallValidateAllocateMemory(
         }
     }
     skip |= validate_required_pointer("vkAllocateMemory", "pMemory", pMemory, "VUID-vkAllocateMemory-pMemory-parameter");
-    skip |= manual_PreCallValidateAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
+    if (!skip) skip |= manual_PreCallValidateAllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
     return skip;
 }
 
@@ -2084,8 +2151,8 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceSparseImageFormatPrope
     bool skip = false;
     skip |= validate_ranged_enum("vkGetPhysicalDeviceSparseImageFormatProperties", "format", "VkFormat", AllVkFormatEnums, format, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-format-parameter");
     skip |= validate_ranged_enum("vkGetPhysicalDeviceSparseImageFormatProperties", "type", "VkImageType", AllVkImageTypeEnums, type, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-type-parameter");
-    skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties", "samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, samples, true, true, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter");
-    skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true, false, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask");
+    skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties", "samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, samples, kRequiredSingleBit, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter", "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-samples-parameter");
+    skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, kRequiredFlags, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-parameter", "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-usage-requiredbitmask");
     skip |= validate_ranged_enum("vkGetPhysicalDeviceSparseImageFormatProperties", "tiling", "VkImageTiling", AllVkImageTilingEnums, tiling, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-tiling-parameter");
     skip |= validate_array("vkGetPhysicalDeviceSparseImageFormatProperties", "pPropertyCount", "pProperties", pPropertyCount, &pProperties, true, false, false, kVUIDUndefined, "VUID-vkGetPhysicalDeviceSparseImageFormatProperties-pProperties-parameter");
     if (pProperties != NULL)
@@ -2129,7 +2196,7 @@ bool StatelessValidation::PreCallValidateQueueBindSparse(
                     {
                         for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].bindCount; ++bindIndex)
                         {
-                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds[bindIndex].flags, false, false, "VUID-VkSparseMemoryBind-flags-parameter");
+                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pBufferBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, bufferBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pBufferBinds[bufferBindIndex].pBinds[bindIndex].flags, kOptionalFlags, "VUID-VkSparseMemoryBind-flags-parameter");
                         }
                     }
                 }
@@ -2149,7 +2216,7 @@ bool StatelessValidation::PreCallValidateQueueBindSparse(
                     {
                         for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].bindCount; ++bindIndex)
                         {
-                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds[bindIndex].flags, false, false, "VUID-VkSparseMemoryBind-flags-parameter");
+                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageOpaqueBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageOpaqueBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageOpaqueBinds[imageOpaqueBindIndex].pBinds[bindIndex].flags, kOptionalFlags, "VUID-VkSparseMemoryBind-flags-parameter");
                         }
                     }
                 }
@@ -2169,13 +2236,13 @@ bool StatelessValidation::PreCallValidateQueueBindSparse(
                     {
                         for (uint32_t bindIndex = 0; bindIndex < pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].bindCount; ++bindIndex)
                         {
-                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].subresource.aspectMask", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].subresource.aspectMask, true, false, "VUID-VkImageSubresource-aspectMask-requiredbitmask");
+                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].subresource.aspectMask", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].subresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresource-aspectMask-parameter", "VUID-VkImageSubresource-aspectMask-requiredbitmask");
 
                             // No xml-driven validation
 
                             // No xml-driven validation
 
-                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].flags, false, false, "VUID-VkSparseImageMemoryBind-flags-parameter");
+                            skip |= validate_flags("vkQueueBindSparse", ParameterName("pBindInfo[%i].pImageBinds[%i].pBinds[%i].flags", ParameterName::IndexVector{ bindInfoIndex, imageBindIndex, bindIndex }), "VkSparseMemoryBindFlagBits", AllVkSparseMemoryBindFlagBits, pBindInfo[bindInfoIndex].pImageBinds[imageBindIndex].pBinds[bindIndex].flags, kOptionalFlags, "VUID-VkSparseImageMemoryBind-flags-parameter");
                         }
                     }
                 }
@@ -2200,7 +2267,7 @@ bool StatelessValidation::PreCallValidateCreateFence(
 
         skip |= validate_struct_pnext("vkCreateFence", "pCreateInfo->pNext", "VkExportFenceCreateInfo, VkExportFenceWin32HandleInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkFenceCreateInfo), allowed_structs_VkFenceCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkFenceCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateFence", "pCreateInfo->flags", "VkFenceCreateFlagBits", AllVkFenceCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkFenceCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateFence", "pCreateInfo->flags", "VkFenceCreateFlagBits", AllVkFenceCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkFenceCreateInfo-flags-parameter");
     }
     if (pAllocator != NULL)
     {
@@ -2518,7 +2585,7 @@ bool StatelessValidation::PreCallValidateGetQueryPoolResults(
     bool skip = false;
     skip |= validate_required_handle("vkGetQueryPoolResults", "queryPool", queryPool);
     skip |= validate_array("vkGetQueryPoolResults", "dataSize", "pData", dataSize, &pData, true, true, "VUID-vkGetQueryPoolResults-dataSize-arraylength", "VUID-vkGetQueryPoolResults-pData-parameter");
-    skip |= validate_flags("vkGetQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false, false, "VUID-vkGetQueryPoolResults-flags-parameter");
+    skip |= validate_flags("vkGetQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, kOptionalFlags, "VUID-vkGetQueryPoolResults-flags-parameter");
     return skip;
 }
 
@@ -2535,9 +2602,9 @@ bool StatelessValidation::PreCallValidateCreateBuffer(
 
         skip |= validate_struct_pnext("vkCreateBuffer", "pCreateInfo->pNext", "VkBufferDeviceAddressCreateInfoEXT, VkDedicatedAllocationBufferCreateInfoNV, VkExternalMemoryBufferCreateInfo", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkBufferCreateInfo), allowed_structs_VkBufferCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkBufferCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateBuffer", "pCreateInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkBufferCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateBuffer", "pCreateInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkBufferCreateInfo-flags-parameter");
 
-        skip |= validate_flags("vkCreateBuffer", "pCreateInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pCreateInfo->usage, true, false, "VUID-VkBufferCreateInfo-usage-requiredbitmask");
+        skip |= validate_flags("vkCreateBuffer", "pCreateInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pCreateInfo->usage, kRequiredFlags, "VUID-VkBufferCreateInfo-usage-parameter", "VUID-VkBufferCreateInfo-usage-requiredbitmask");
 
         skip |= validate_ranged_enum("vkCreateBuffer", "pCreateInfo->sharingMode", "VkSharingMode", AllVkSharingModeEnums, pCreateInfo->sharingMode, "VUID-VkBufferCreateInfo-sharingMode-parameter");
     }
@@ -2562,7 +2629,7 @@ bool StatelessValidation::PreCallValidateCreateBuffer(
         }
     }
     skip |= validate_required_pointer("vkCreateBuffer", "pBuffer", pBuffer, "VUID-vkCreateBuffer-pBuffer-parameter");
-    skip |= manual_PreCallValidateCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
+    if (!skip) skip |= manual_PreCallValidateCreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
     return skip;
 }
 
@@ -2676,7 +2743,7 @@ bool StatelessValidation::PreCallValidateCreateImage(
 
         skip |= validate_struct_pnext("vkCreateImage", "pCreateInfo->pNext", "VkDedicatedAllocationImageCreateInfoNV, VkExternalFormatANDROID, VkExternalMemoryImageCreateInfo, VkExternalMemoryImageCreateInfoNV, VkImageDrmFormatModifierExplicitCreateInfoEXT, VkImageDrmFormatModifierListCreateInfoEXT, VkImageFormatListCreateInfoKHR, VkImageStencilUsageCreateInfoEXT, VkImageSwapchainCreateInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageCreateInfo), allowed_structs_VkImageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkImageCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateImage", "pCreateInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkImageCreateInfo-flags-parameter");
 
         skip |= validate_ranged_enum("vkCreateImage", "pCreateInfo->imageType", "VkImageType", AllVkImageTypeEnums, pCreateInfo->imageType, "VUID-VkImageCreateInfo-imageType-parameter");
 
@@ -2684,11 +2751,11 @@ bool StatelessValidation::PreCallValidateCreateImage(
 
         // No xml-driven validation
 
-        skip |= validate_flags("vkCreateImage", "pCreateInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->samples, true, true, "VUID-VkImageCreateInfo-samples-parameter");
+        skip |= validate_flags("vkCreateImage", "pCreateInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->samples, kRequiredSingleBit, "VUID-VkImageCreateInfo-samples-parameter", "VUID-VkImageCreateInfo-samples-parameter");
 
         skip |= validate_ranged_enum("vkCreateImage", "pCreateInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pCreateInfo->tiling, "VUID-VkImageCreateInfo-tiling-parameter");
 
-        skip |= validate_flags("vkCreateImage", "pCreateInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->usage, true, false, "VUID-VkImageCreateInfo-usage-requiredbitmask");
+        skip |= validate_flags("vkCreateImage", "pCreateInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->usage, kRequiredFlags, "VUID-VkImageCreateInfo-usage-parameter", "VUID-VkImageCreateInfo-usage-requiredbitmask");
 
         skip |= validate_ranged_enum("vkCreateImage", "pCreateInfo->sharingMode", "VkSharingMode", AllVkSharingModeEnums, pCreateInfo->sharingMode, "VUID-VkImageCreateInfo-sharingMode-parameter");
 
@@ -2715,7 +2782,7 @@ bool StatelessValidation::PreCallValidateCreateImage(
         }
     }
     skip |= validate_required_pointer("vkCreateImage", "pImage", pImage, "VUID-vkCreateImage-pImage-parameter");
-    skip |= manual_PreCallValidateCreateImage(device, pCreateInfo, pAllocator, pImage);
+    if (!skip) skip |= manual_PreCallValidateCreateImage(device, pCreateInfo, pAllocator, pImage);
     return skip;
 }
 
@@ -2757,7 +2824,7 @@ bool StatelessValidation::PreCallValidateGetImageSubresourceLayout(
     skip |= validate_required_pointer("vkGetImageSubresourceLayout", "pSubresource", pSubresource, "VUID-vkGetImageSubresourceLayout-pSubresource-parameter");
     if (pSubresource != NULL)
     {
-        skip |= validate_flags("vkGetImageSubresourceLayout", "pSubresource->aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pSubresource->aspectMask, true, false, "VUID-VkImageSubresource-aspectMask-requiredbitmask");
+        skip |= validate_flags("vkGetImageSubresourceLayout", "pSubresource->aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pSubresource->aspectMask, kRequiredFlags, "VUID-VkImageSubresource-aspectMask-parameter", "VUID-VkImageSubresource-aspectMask-requiredbitmask");
     }
     skip |= validate_required_pointer("vkGetImageSubresourceLayout", "pLayout", pLayout, "VUID-vkGetImageSubresourceLayout-pLayout-parameter");
     if (pLayout != NULL)
@@ -2780,7 +2847,7 @@ bool StatelessValidation::PreCallValidateCreateImageView(
 
         skip |= validate_struct_pnext("vkCreateImageView", "pCreateInfo->pNext", "VkImageViewASTCDecodeModeEXT, VkImageViewUsageCreateInfo, VkSamplerYcbcrConversionInfo", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkImageViewCreateInfo), allowed_structs_VkImageViewCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkImageViewCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateImageView", "pCreateInfo->flags", "VkImageViewCreateFlagBits", AllVkImageViewCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkImageViewCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateImageView", "pCreateInfo->flags", "VkImageViewCreateFlagBits", AllVkImageViewCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkImageViewCreateInfo-flags-parameter");
 
         skip |= validate_required_handle("vkCreateImageView", "pCreateInfo->image", pCreateInfo->image);
 
@@ -2796,7 +2863,7 @@ bool StatelessValidation::PreCallValidateCreateImageView(
 
         skip |= validate_ranged_enum("vkCreateImageView", "pCreateInfo->components.a", "VkComponentSwizzle", AllVkComponentSwizzleEnums, pCreateInfo->components.a, "VUID-VkComponentMapping-a-parameter");
 
-        skip |= validate_flags("vkCreateImageView", "pCreateInfo->subresourceRange.aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pCreateInfo->subresourceRange.aspectMask, true, false, "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
+        skip |= validate_flags("vkCreateImageView", "pCreateInfo->subresourceRange.aspectMask", "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pCreateInfo->subresourceRange.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceRange-aspectMask-parameter", "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
     }
     if (pAllocator != NULL)
     {
@@ -2819,7 +2886,6 @@ bool StatelessValidation::PreCallValidateCreateImageView(
         }
     }
     skip |= validate_required_pointer("vkCreateImageView", "pView", pView, "VUID-vkCreateImageView-pView-parameter");
-    skip |= manual_PreCallValidateCreateImageView(device, pCreateInfo, pAllocator, pView);
     return skip;
 }
 
@@ -2864,7 +2930,7 @@ bool StatelessValidation::PreCallValidateCreateShaderModule(
 
         skip |= validate_struct_pnext("vkCreateShaderModule", "pCreateInfo->pNext", "VkShaderModuleValidationCacheCreateInfoEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkShaderModuleCreateInfo), allowed_structs_VkShaderModuleCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkShaderModuleCreateInfo-pNext-pNext");
 
-        skip |= validate_reserved_flags("vkCreateShaderModule", "pCreateInfo->flags", pCreateInfo->flags, "VUID-VkShaderModuleCreateInfo-flags-zerobitmask");
+        skip |= validate_reserved_flags("vkCreateShaderModule", "pCreateInfo->flags", pCreateInfo->flags, kVUIDUndefined);
 
         skip |= validate_array("vkCreateShaderModule", "pCreateInfo->codeSize", "pCreateInfo->pCode", pCreateInfo->codeSize, &pCreateInfo->pCode, true, true, kVUIDUndefined, "VUID-VkShaderModuleCreateInfo-pCode-parameter");
     }
@@ -3022,11 +3088,11 @@ bool StatelessValidation::PreCallValidateCreateGraphicsPipelines(
     {
         for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex)
         {
-            const VkStructureType allowed_structs_VkGraphicsPipelineCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV };
+            const VkStructureType allowed_structs_VkGraphicsPipelineCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV };
 
-            skip |= validate_struct_pnext("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreationFeedbackCreateInfoEXT, VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineRepresentativeFragmentTestStateCreateInfoNV", pCreateInfos[createInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkGraphicsPipelineCreateInfo), allowed_structs_VkGraphicsPipelineCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext");
+            skip |= validate_struct_pnext("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreationFeedbackCreateInfoEXT, VkPipelineDiscardRectangleStateCreateInfoEXT, VkPipelineRepresentativeFragmentTestStateCreateInfoNV", pCreateInfos[createInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkGraphicsPipelineCreateInfo), allowed_structs_VkGraphicsPipelineCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkGraphicsPipelineCreateInfo-pNext-pNext");
 
-            skip |= validate_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false, false, "VUID-VkGraphicsPipelineCreateInfo-flags-parameter");
+            skip |= validate_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, kOptionalFlags, "VUID-VkGraphicsPipelineCreateInfo-flags-parameter");
 
             skip |= validate_struct_type_array("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].stageCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pStages", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", pCreateInfos[createInfoIndex].stageCount, pCreateInfos[createInfoIndex].pStages, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, true, true, "VUID-VkPipelineShaderStageCreateInfo-sType-sType", "VUID-VkGraphicsPipelineCreateInfo-pStages-parameter", "VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength");
 
@@ -3034,11 +3100,13 @@ bool StatelessValidation::PreCallValidateCreateGraphicsPipelines(
             {
                 for (uint32_t stageIndex = 0; stageIndex < pCreateInfos[createInfoIndex].stageCount; ++stageIndex)
                 {
-                    skip |= validate_struct_pnext("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pNext", ParameterName::IndexVector{ createInfoIndex, stageIndex }), NULL, pCreateInfos[createInfoIndex].pStages[stageIndex].pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext");
+                    const VkStructureType allowed_structs_VkPipelineShaderStageCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT };
+
+                    skip |= validate_struct_pnext("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].pNext", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT", pCreateInfos[createInfoIndex].pStages[stageIndex].pNext, ARRAY_SIZE(allowed_structs_VkPipelineShaderStageCreateInfo), allowed_structs_VkPipelineShaderStageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext");
 
-                    skip |= validate_reserved_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].flags", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].flags, "VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask");
+                    skip |= validate_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].flags", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkPipelineShaderStageCreateFlagBits", AllVkPipelineShaderStageCreateFlagBits, pCreateInfos[createInfoIndex].pStages[stageIndex].flags, kOptionalFlags, "VUID-VkPipelineShaderStageCreateInfo-flags-parameter");
 
-                    skip |= validate_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].stage", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].pStages[stageIndex].stage, true, true, "VUID-VkPipelineShaderStageCreateInfo-stage-parameter");
+                    skip |= validate_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].stage", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].pStages[stageIndex].stage, kRequiredSingleBit, "VUID-VkPipelineShaderStageCreateInfo-stage-parameter", "VUID-VkPipelineShaderStageCreateInfo-stage-parameter");
 
                     skip |= validate_required_handle("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pStages[%i].module", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].module);
 
@@ -3065,9 +3133,9 @@ bool StatelessValidation::PreCallValidateCreateGraphicsPipelines(
 
             if (pCreateInfos[createInfoIndex].pRasterizationState != NULL)
             {
-                const VkStructureType allowed_structs_VkPipelineRasterizationStateCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT };
+                const VkStructureType allowed_structs_VkPipelineRasterizationStateCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD, VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT };
 
-                skip |= validate_struct_pnext("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineRasterizationConservativeStateCreateInfoEXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT, VkPipelineRasterizationStateRasterizationOrderAMD, VkPipelineRasterizationStateStreamCreateInfoEXT", pCreateInfos[createInfoIndex].pRasterizationState->pNext, ARRAY_SIZE(allowed_structs_VkPipelineRasterizationStateCreateInfo), allowed_structs_VkPipelineRasterizationStateCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext");
+                skip |= validate_struct_pnext("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineRasterizationConservativeStateCreateInfoEXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT, VkPipelineRasterizationLineStateCreateInfoEXT, VkPipelineRasterizationStateRasterizationOrderAMD, VkPipelineRasterizationStateStreamCreateInfoEXT", pCreateInfos[createInfoIndex].pRasterizationState->pNext, ARRAY_SIZE(allowed_structs_VkPipelineRasterizationStateCreateInfo), allowed_structs_VkPipelineRasterizationStateCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext");
 
                 skip |= validate_reserved_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].pRasterizationState->flags, "VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask");
 
@@ -3077,7 +3145,7 @@ bool StatelessValidation::PreCallValidateCreateGraphicsPipelines(
 
                 skip |= validate_ranged_enum("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->polygonMode", ParameterName::IndexVector{ createInfoIndex }), "VkPolygonMode", AllVkPolygonModeEnums, pCreateInfos[createInfoIndex].pRasterizationState->polygonMode, "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-parameter");
 
-                skip |= validate_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->cullMode", ParameterName::IndexVector{ createInfoIndex }), "VkCullModeFlagBits", AllVkCullModeFlagBits, pCreateInfos[createInfoIndex].pRasterizationState->cullMode, false, false, "VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter");
+                skip |= validate_flags("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->cullMode", ParameterName::IndexVector{ createInfoIndex }), "VkCullModeFlagBits", AllVkCullModeFlagBits, pCreateInfos[createInfoIndex].pRasterizationState->cullMode, kOptionalFlags, "VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter");
 
                 skip |= validate_ranged_enum("vkCreateGraphicsPipelines", ParameterName("pCreateInfos[%i].pRasterizationState->frontFace", ParameterName::IndexVector{ createInfoIndex }), "VkFrontFace", AllVkFrontFaceEnums, pCreateInfos[createInfoIndex].pRasterizationState->frontFace, "VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter");
 
@@ -3121,7 +3189,7 @@ bool StatelessValidation::PreCallValidateCreateGraphicsPipelines(
         }
     }
     skip |= validate_array("vkCreateGraphicsPipelines", "createInfoCount", "pPipelines", createInfoCount, &pPipelines, true, true, "VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength", "VUID-vkCreateGraphicsPipelines-pPipelines-parameter");
-    skip |= manual_PreCallValidateCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    if (!skip) skip |= manual_PreCallValidateCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     return skip;
 }
 
@@ -3138,19 +3206,21 @@ bool StatelessValidation::PreCallValidateCreateComputePipelines(
     {
         for (uint32_t createInfoIndex = 0; createInfoIndex < createInfoCount; ++createInfoIndex)
         {
-            const VkStructureType allowed_structs_VkComputePipelineCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT };
+            const VkStructureType allowed_structs_VkComputePipelineCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD, VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT };
 
-            skip |= validate_struct_pnext("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreationFeedbackCreateInfoEXT", pCreateInfos[createInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkComputePipelineCreateInfo), allowed_structs_VkComputePipelineCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkComputePipelineCreateInfo-pNext-pNext");
+            skip |= validate_struct_pnext("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreationFeedbackCreateInfoEXT", pCreateInfos[createInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkComputePipelineCreateInfo), allowed_structs_VkComputePipelineCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkComputePipelineCreateInfo-pNext-pNext");
 
-            skip |= validate_flags("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false, false, "VUID-VkComputePipelineCreateInfo-flags-parameter");
+            skip |= validate_flags("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, kOptionalFlags, "VUID-VkComputePipelineCreateInfo-flags-parameter");
 
             skip |= validate_struct_type("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", &(pCreateInfos[createInfoIndex].stage), VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, false, kVUIDUndefined, "VUID-VkPipelineShaderStageCreateInfo-sType-sType");
 
-            skip |= validate_struct_pnext("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pNext", ParameterName::IndexVector{ createInfoIndex }), NULL, pCreateInfos[createInfoIndex].stage.pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext");
+            const VkStructureType allowed_structs_VkPipelineShaderStageCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT };
+
+            skip |= validate_struct_pnext("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT", pCreateInfos[createInfoIndex].stage.pNext, ARRAY_SIZE(allowed_structs_VkPipelineShaderStageCreateInfo), allowed_structs_VkPipelineShaderStageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext");
 
-            skip |= validate_reserved_flags("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.flags", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.flags, "VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask");
+            skip |= validate_flags("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineShaderStageCreateFlagBits", AllVkPipelineShaderStageCreateFlagBits, pCreateInfos[createInfoIndex].stage.flags, kOptionalFlags, "VUID-VkPipelineShaderStageCreateInfo-flags-parameter");
 
-            skip |= validate_flags("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.stage", ParameterName::IndexVector{ createInfoIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].stage.stage, true, true, "VUID-VkPipelineShaderStageCreateInfo-stage-parameter");
+            skip |= validate_flags("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.stage", ParameterName::IndexVector{ createInfoIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].stage.stage, kRequiredSingleBit, "VUID-VkPipelineShaderStageCreateInfo-stage-parameter", "VUID-VkPipelineShaderStageCreateInfo-stage-parameter");
 
             skip |= validate_required_handle("vkCreateComputePipelines", ParameterName("pCreateInfos[%i].stage.module", ParameterName::IndexVector{ createInfoIndex }), pCreateInfos[createInfoIndex].stage.module);
 
@@ -3195,7 +3265,7 @@ bool StatelessValidation::PreCallValidateCreateComputePipelines(
         }
     }
     skip |= validate_array("vkCreateComputePipelines", "createInfoCount", "pPipelines", createInfoCount, &pPipelines, true, true, "VUID-vkCreateComputePipelines-createInfoCount-arraylength", "VUID-vkCreateComputePipelines-pPipelines-parameter");
-    skip |= manual_PreCallValidateCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    if (!skip) skip |= manual_PreCallValidateCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     return skip;
 }
 
@@ -3248,7 +3318,7 @@ bool StatelessValidation::PreCallValidateCreatePipelineLayout(
         {
             for (uint32_t pushConstantRangeIndex = 0; pushConstantRangeIndex < pCreateInfo->pushConstantRangeCount; ++pushConstantRangeIndex)
             {
-                skip |= validate_flags("vkCreatePipelineLayout", ParameterName("pCreateInfo->pPushConstantRanges[%i].stageFlags", ParameterName::IndexVector{ pushConstantRangeIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfo->pPushConstantRanges[pushConstantRangeIndex].stageFlags, true, false, "VUID-VkPushConstantRange-stageFlags-requiredbitmask");
+                skip |= validate_flags("vkCreatePipelineLayout", ParameterName("pCreateInfo->pPushConstantRanges[%i].stageFlags", ParameterName::IndexVector{ pushConstantRangeIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfo->pPushConstantRanges[pushConstantRangeIndex].stageFlags, kRequiredFlags, "VUID-VkPushConstantRange-stageFlags-parameter", "VUID-VkPushConstantRange-stageFlags-requiredbitmask");
             }
         }
     }
@@ -3317,7 +3387,7 @@ bool StatelessValidation::PreCallValidateCreateSampler(
 
         skip |= validate_struct_pnext("vkCreateSampler", "pCreateInfo->pNext", "VkSamplerReductionModeCreateInfoEXT, VkSamplerYcbcrConversionInfo", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSamplerCreateInfo), allowed_structs_VkSamplerCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkSamplerCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateSampler", "pCreateInfo->flags", "VkSamplerCreateFlagBits", AllVkSamplerCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkSamplerCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateSampler", "pCreateInfo->flags", "VkSamplerCreateFlagBits", AllVkSamplerCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkSamplerCreateInfo-flags-parameter");
 
         skip |= validate_ranged_enum("vkCreateSampler", "pCreateInfo->magFilter", "VkFilter", AllVkFilterEnums, pCreateInfo->magFilter, "VUID-VkSamplerCreateInfo-magFilter-parameter");
 
@@ -3358,7 +3428,7 @@ bool StatelessValidation::PreCallValidateCreateSampler(
         }
     }
     skip |= validate_required_pointer("vkCreateSampler", "pSampler", pSampler, "VUID-vkCreateSampler-pSampler-parameter");
-    skip |= manual_PreCallValidateCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+    if (!skip) skip |= manual_PreCallValidateCreateSampler(device, pCreateInfo, pAllocator, pSampler);
     return skip;
 }
 
@@ -3403,7 +3473,7 @@ bool StatelessValidation::PreCallValidateCreateDescriptorSetLayout(
 
         skip |= validate_struct_pnext("vkCreateDescriptorSetLayout", "pCreateInfo->pNext", "VkDescriptorSetLayoutBindingFlagsCreateInfoEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkDescriptorSetLayoutCreateInfo), allowed_structs_VkDescriptorSetLayoutCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateDescriptorSetLayout", "pCreateInfo->flags", "VkDescriptorSetLayoutCreateFlagBits", AllVkDescriptorSetLayoutCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateDescriptorSetLayout", "pCreateInfo->flags", "VkDescriptorSetLayoutCreateFlagBits", AllVkDescriptorSetLayoutCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter");
 
         skip |= validate_array("vkCreateDescriptorSetLayout", "pCreateInfo->bindingCount", "pCreateInfo->pBindings", pCreateInfo->bindingCount, &pCreateInfo->pBindings, false, true, kVUIDUndefined, "VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter");
 
@@ -3436,7 +3506,7 @@ bool StatelessValidation::PreCallValidateCreateDescriptorSetLayout(
         }
     }
     skip |= validate_required_pointer("vkCreateDescriptorSetLayout", "pSetLayout", pSetLayout, "VUID-vkCreateDescriptorSetLayout-pSetLayout-parameter");
-    skip |= manual_PreCallValidateCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+    if (!skip) skip |= manual_PreCallValidateCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
     return skip;
 }
 
@@ -3481,7 +3551,7 @@ bool StatelessValidation::PreCallValidateCreateDescriptorPool(
 
         skip |= validate_struct_pnext("vkCreateDescriptorPool", "pCreateInfo->pNext", "VkDescriptorPoolInlineUniformBlockCreateInfoEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkDescriptorPoolCreateInfo), allowed_structs_VkDescriptorPoolCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkDescriptorPoolCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateDescriptorPool", "pCreateInfo->flags", "VkDescriptorPoolCreateFlagBits", AllVkDescriptorPoolCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkDescriptorPoolCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateDescriptorPool", "pCreateInfo->flags", "VkDescriptorPoolCreateFlagBits", AllVkDescriptorPoolCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkDescriptorPoolCreateInfo-flags-parameter");
 
         skip |= validate_array("vkCreateDescriptorPool", "pCreateInfo->poolSizeCount", "pCreateInfo->pPoolSizes", pCreateInfo->poolSizeCount, &pCreateInfo->pPoolSizes, true, true, "VUID-VkDescriptorPoolCreateInfo-poolSizeCount-arraylength", "VUID-VkDescriptorPoolCreateInfo-pPoolSizes-parameter");
 
@@ -3514,7 +3584,7 @@ bool StatelessValidation::PreCallValidateCreateDescriptorPool(
         }
     }
     skip |= validate_required_pointer("vkCreateDescriptorPool", "pDescriptorPool", pDescriptorPool, "VUID-vkCreateDescriptorPool-pDescriptorPool-parameter");
-    skip |= manual_PreCallValidateCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+    if (!skip) skip |= manual_PreCallValidateCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
     return skip;
 }
 
@@ -3585,7 +3655,7 @@ bool StatelessValidation::PreCallValidateFreeDescriptorSets(
     const VkDescriptorSet*                      pDescriptorSets) {
     bool skip = false;
     skip |= validate_required_handle("vkFreeDescriptorSets", "descriptorPool", descriptorPool);
-    skip |= manual_PreCallValidateFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    if (!skip) skip |= manual_PreCallValidateFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
     return skip;
 }
 
@@ -3620,7 +3690,7 @@ bool StatelessValidation::PreCallValidateUpdateDescriptorSets(
             skip |= validate_required_handle("vkUpdateDescriptorSets", ParameterName("pDescriptorCopies[%i].dstSet", ParameterName::IndexVector{ descriptorCopyIndex }), pDescriptorCopies[descriptorCopyIndex].dstSet);
         }
     }
-    skip |= manual_PreCallValidateUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+    if (!skip) skip |= manual_PreCallValidateUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
     return skip;
 }
 
@@ -3637,11 +3707,9 @@ bool StatelessValidation::PreCallValidateCreateFramebuffer(
 
         skip |= validate_struct_pnext("vkCreateFramebuffer", "pCreateInfo->pNext", "VkFramebufferAttachmentsCreateInfoKHR", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkFramebufferCreateInfo), allowed_structs_VkFramebufferCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkFramebufferCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateFramebuffer", "pCreateInfo->flags", "VkFramebufferCreateFlagBits", AllVkFramebufferCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkFramebufferCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateFramebuffer", "pCreateInfo->flags", "VkFramebufferCreateFlagBits", AllVkFramebufferCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkFramebufferCreateInfo-flags-parameter");
 
         skip |= validate_required_handle("vkCreateFramebuffer", "pCreateInfo->renderPass", pCreateInfo->renderPass);
-
-        skip |= validate_array("vkCreateFramebuffer", "pCreateInfo->attachmentCount", "pCreateInfo->pAttachments", pCreateInfo->attachmentCount, &pCreateInfo->pAttachments, false, true, kVUIDUndefined, "VUID-VkFramebufferCreateInfo-pAttachments-parameter");
     }
     if (pAllocator != NULL)
     {
@@ -3664,6 +3732,7 @@ bool StatelessValidation::PreCallValidateCreateFramebuffer(
         }
     }
     skip |= validate_required_pointer("vkCreateFramebuffer", "pFramebuffer", pFramebuffer, "VUID-vkCreateFramebuffer-pFramebuffer-parameter");
+    if (!skip) skip |= manual_PreCallValidateCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
     return skip;
 }
 
@@ -3714,11 +3783,11 @@ bool StatelessValidation::PreCallValidateCreateRenderPass(
         {
             for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfo->attachmentCount; ++attachmentIndex)
             {
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].flags", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentDescriptionFlagBits", AllVkAttachmentDescriptionFlagBits, pCreateInfo->pAttachments[attachmentIndex].flags, false, false, "VUID-VkAttachmentDescription-flags-parameter");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].flags", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentDescriptionFlagBits", AllVkAttachmentDescriptionFlagBits, pCreateInfo->pAttachments[attachmentIndex].flags, kOptionalFlags, "VUID-VkAttachmentDescription-flags-parameter");
 
                 skip |= validate_ranged_enum("vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].format", ParameterName::IndexVector{ attachmentIndex }), "VkFormat", AllVkFormatEnums, pCreateInfo->pAttachments[attachmentIndex].format, "VUID-VkAttachmentDescription-format-parameter");
 
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].samples", ParameterName::IndexVector{ attachmentIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->pAttachments[attachmentIndex].samples, true, true, "VUID-VkAttachmentDescription-samples-parameter");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].samples", ParameterName::IndexVector{ attachmentIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->pAttachments[attachmentIndex].samples, kRequiredSingleBit, "VUID-VkAttachmentDescription-samples-parameter", "VUID-VkAttachmentDescription-samples-parameter");
 
                 skip |= validate_ranged_enum("vkCreateRenderPass", ParameterName("pCreateInfo->pAttachments[%i].loadOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentLoadOp", AllVkAttachmentLoadOpEnums, pCreateInfo->pAttachments[attachmentIndex].loadOp, "VUID-VkAttachmentDescription-loadOp-parameter");
 
@@ -3740,7 +3809,7 @@ bool StatelessValidation::PreCallValidateCreateRenderPass(
         {
             for (uint32_t subpassIndex = 0; subpassIndex < pCreateInfo->subpassCount; ++subpassIndex)
             {
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].flags", ParameterName::IndexVector{ subpassIndex }), "VkSubpassDescriptionFlagBits", AllVkSubpassDescriptionFlagBits, pCreateInfo->pSubpasses[subpassIndex].flags, false, false, "VUID-VkSubpassDescription-flags-parameter");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].flags", ParameterName::IndexVector{ subpassIndex }), "VkSubpassDescriptionFlagBits", AllVkSubpassDescriptionFlagBits, pCreateInfo->pSubpasses[subpassIndex].flags, kOptionalFlags, "VUID-VkSubpassDescription-flags-parameter");
 
                 skip |= validate_ranged_enum("vkCreateRenderPass", ParameterName("pCreateInfo->pSubpasses[%i].pipelineBindPoint", ParameterName::IndexVector{ subpassIndex }), "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pCreateInfo->pSubpasses[subpassIndex].pipelineBindPoint, "VUID-VkSubpassDescription-pipelineBindPoint-parameter");
 
@@ -3787,15 +3856,15 @@ bool StatelessValidation::PreCallValidateCreateRenderPass(
         {
             for (uint32_t dependencyIndex = 0; dependencyIndex < pCreateInfo->dependencyCount; ++dependencyIndex)
             {
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcStageMask, true, false, "VUID-VkSubpassDependency-srcStageMask-requiredbitmask");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcStageMask, kRequiredFlags, "VUID-VkSubpassDependency-srcStageMask-parameter", "VUID-VkSubpassDependency-srcStageMask-requiredbitmask");
 
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstStageMask, true, false, "VUID-VkSubpassDependency-dstStageMask-requiredbitmask");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstStageMask, kRequiredFlags, "VUID-VkSubpassDependency-dstStageMask-parameter", "VUID-VkSubpassDependency-dstStageMask-requiredbitmask");
 
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcAccessMask, false, false, "VUID-VkSubpassDependency-srcAccessMask-parameter");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].srcAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcAccessMask, kOptionalFlags, "VUID-VkSubpassDependency-srcAccessMask-parameter");
 
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstAccessMask, false, false, "VUID-VkSubpassDependency-dstAccessMask-parameter");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dstAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstAccessMask, kOptionalFlags, "VUID-VkSubpassDependency-dstAccessMask-parameter");
 
-                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dependencyFlags", ParameterName::IndexVector{ dependencyIndex }), "VkDependencyFlagBits", AllVkDependencyFlagBits, pCreateInfo->pDependencies[dependencyIndex].dependencyFlags, false, false, "VUID-VkSubpassDependency-dependencyFlags-parameter");
+                skip |= validate_flags("vkCreateRenderPass", ParameterName("pCreateInfo->pDependencies[%i].dependencyFlags", ParameterName::IndexVector{ dependencyIndex }), "VkDependencyFlagBits", AllVkDependencyFlagBits, pCreateInfo->pDependencies[dependencyIndex].dependencyFlags, kOptionalFlags, "VUID-VkSubpassDependency-dependencyFlags-parameter");
             }
         }
     }
@@ -3820,7 +3889,7 @@ bool StatelessValidation::PreCallValidateCreateRenderPass(
         }
     }
     skip |= validate_required_pointer("vkCreateRenderPass", "pRenderPass", pRenderPass, "VUID-vkCreateRenderPass-pRenderPass-parameter");
-    skip |= manual_PreCallValidateCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
+    if (!skip) skip |= manual_PreCallValidateCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
     return skip;
 }
 
@@ -3873,7 +3942,7 @@ bool StatelessValidation::PreCallValidateCreateCommandPool(
     {
         skip |= validate_struct_pnext("vkCreateCommandPool", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkCommandPoolCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkCreateCommandPool", "pCreateInfo->flags", "VkCommandPoolCreateFlagBits", AllVkCommandPoolCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkCommandPoolCreateInfo-flags-parameter");
+        skip |= validate_flags("vkCreateCommandPool", "pCreateInfo->flags", "VkCommandPoolCreateFlagBits", AllVkCommandPoolCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkCommandPoolCreateInfo-flags-parameter");
     }
     if (pAllocator != NULL)
     {
@@ -3933,7 +4002,7 @@ bool StatelessValidation::PreCallValidateResetCommandPool(
     VkCommandPoolResetFlags                     flags) {
     bool skip = false;
     skip |= validate_required_handle("vkResetCommandPool", "commandPool", commandPool);
-    skip |= validate_flags("vkResetCommandPool", "flags", "VkCommandPoolResetFlagBits", AllVkCommandPoolResetFlagBits, flags, false, false, "VUID-vkResetCommandPool-flags-parameter");
+    skip |= validate_flags("vkResetCommandPool", "flags", "VkCommandPoolResetFlagBits", AllVkCommandPoolResetFlagBits, flags, kOptionalFlags, "VUID-vkResetCommandPool-flags-parameter");
     return skip;
 }
 
@@ -3978,9 +4047,9 @@ bool StatelessValidation::PreCallValidateBeginCommandBuffer(
 
         skip |= validate_struct_pnext("vkBeginCommandBuffer", "pBeginInfo->pNext", "VkDeviceGroupCommandBufferBeginInfo", pBeginInfo->pNext, ARRAY_SIZE(allowed_structs_VkCommandBufferBeginInfo), allowed_structs_VkCommandBufferBeginInfo, GeneratedVulkanHeaderVersion, "VUID-VkCommandBufferBeginInfo-pNext-pNext");
 
-        skip |= validate_flags("vkBeginCommandBuffer", "pBeginInfo->flags", "VkCommandBufferUsageFlagBits", AllVkCommandBufferUsageFlagBits, pBeginInfo->flags, false, false, "VUID-VkCommandBufferBeginInfo-flags-parameter");
+        skip |= validate_flags("vkBeginCommandBuffer", "pBeginInfo->flags", "VkCommandBufferUsageFlagBits", AllVkCommandBufferUsageFlagBits, pBeginInfo->flags, kOptionalFlags, "VUID-VkCommandBufferBeginInfo-flags-parameter");
     }
-    skip |= manual_PreCallValidateBeginCommandBuffer(commandBuffer, pBeginInfo);
+    if (!skip) skip |= manual_PreCallValidateBeginCommandBuffer(commandBuffer, pBeginInfo);
     return skip;
 }
 
@@ -3995,7 +4064,7 @@ bool StatelessValidation::PreCallValidateResetCommandBuffer(
     VkCommandBuffer                             commandBuffer,
     VkCommandBufferResetFlags                   flags) {
     bool skip = false;
-    skip |= validate_flags("vkResetCommandBuffer", "flags", "VkCommandBufferResetFlagBits", AllVkCommandBufferResetFlagBits, flags, false, false, "VUID-vkResetCommandBuffer-flags-parameter");
+    skip |= validate_flags("vkResetCommandBuffer", "flags", "VkCommandBufferResetFlagBits", AllVkCommandBufferResetFlagBits, flags, kOptionalFlags, "VUID-vkResetCommandBuffer-flags-parameter");
     return skip;
 }
 
@@ -4023,7 +4092,7 @@ bool StatelessValidation::PreCallValidateCmdSetViewport(
             // No xml-driven validation
         }
     }
-    skip |= manual_PreCallValidateCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
+    if (!skip) skip |= manual_PreCallValidateCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
     return skip;
 }
 
@@ -4043,7 +4112,7 @@ bool StatelessValidation::PreCallValidateCmdSetScissor(
             // No xml-driven validation
         }
     }
-    skip |= manual_PreCallValidateCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
+    if (!skip) skip |= manual_PreCallValidateCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
     return skip;
 }
 
@@ -4052,7 +4121,7 @@ bool StatelessValidation::PreCallValidateCmdSetLineWidth(
     float                                       lineWidth) {
     bool skip = false;
     // No xml-driven validation
-    skip |= manual_PreCallValidateCmdSetLineWidth(commandBuffer, lineWidth);
+    if (!skip) skip |= manual_PreCallValidateCmdSetLineWidth(commandBuffer, lineWidth);
     return skip;
 }
 
@@ -4088,7 +4157,7 @@ bool StatelessValidation::PreCallValidateCmdSetStencilCompareMask(
     VkStencilFaceFlags                          faceMask,
     uint32_t                                    compareMask) {
     bool skip = false;
-    skip |= validate_flags("vkCmdSetStencilCompareMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true, false, "VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask");
+    skip |= validate_flags("vkCmdSetStencilCompareMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, kRequiredFlags, "VUID-vkCmdSetStencilCompareMask-faceMask-parameter", "VUID-vkCmdSetStencilCompareMask-faceMask-requiredbitmask");
     return skip;
 }
 
@@ -4097,7 +4166,7 @@ bool StatelessValidation::PreCallValidateCmdSetStencilWriteMask(
     VkStencilFaceFlags                          faceMask,
     uint32_t                                    writeMask) {
     bool skip = false;
-    skip |= validate_flags("vkCmdSetStencilWriteMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true, false, "VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask");
+    skip |= validate_flags("vkCmdSetStencilWriteMask", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, kRequiredFlags, "VUID-vkCmdSetStencilWriteMask-faceMask-parameter", "VUID-vkCmdSetStencilWriteMask-faceMask-requiredbitmask");
     return skip;
 }
 
@@ -4106,7 +4175,7 @@ bool StatelessValidation::PreCallValidateCmdSetStencilReference(
     VkStencilFaceFlags                          faceMask,
     uint32_t                                    reference) {
     bool skip = false;
-    skip |= validate_flags("vkCmdSetStencilReference", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, true, false, "VUID-vkCmdSetStencilReference-faceMask-requiredbitmask");
+    skip |= validate_flags("vkCmdSetStencilReference", "faceMask", "VkStencilFaceFlagBits", AllVkStencilFaceFlagBits, faceMask, kRequiredFlags, "VUID-vkCmdSetStencilReference-faceMask-parameter", "VUID-vkCmdSetStencilReference-faceMask-requiredbitmask");
     return skip;
 }
 
@@ -4135,6 +4204,7 @@ bool StatelessValidation::PreCallValidateCmdBindIndexBuffer(
     bool skip = false;
     skip |= validate_required_handle("vkCmdBindIndexBuffer", "buffer", buffer);
     skip |= validate_ranged_enum("vkCmdBindIndexBuffer", "indexType", "VkIndexType", AllVkIndexTypeEnums, indexType, "VUID-vkCmdBindIndexBuffer-indexType-parameter");
+    if (!skip) skip |= manual_PreCallValidateCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
     return skip;
 }
 
@@ -4158,7 +4228,7 @@ bool StatelessValidation::PreCallValidateCmdDraw(
     uint32_t                                    firstInstance) {
     bool skip = false;
     // No xml-driven validation
-    skip |= manual_PreCallValidateCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+    if (!skip) skip |= manual_PreCallValidateCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
     return skip;
 }
 
@@ -4182,7 +4252,7 @@ bool StatelessValidation::PreCallValidateCmdDrawIndirect(
     uint32_t                                    stride) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdDrawIndirect", "buffer", buffer);
-    skip |= manual_PreCallValidateCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
+    if (!skip) skip |= manual_PreCallValidateCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
     return skip;
 }
 
@@ -4194,7 +4264,7 @@ bool StatelessValidation::PreCallValidateCmdDrawIndexedIndirect(
     uint32_t                                    stride) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdDrawIndexedIndirect", "buffer", buffer);
-    skip |= manual_PreCallValidateCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
+    if (!skip) skip |= manual_PreCallValidateCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
     return skip;
 }
 
@@ -4205,7 +4275,7 @@ bool StatelessValidation::PreCallValidateCmdDispatch(
     uint32_t                                    groupCountZ) {
     bool skip = false;
     // No xml-driven validation
-    skip |= manual_PreCallValidateCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
+    if (!skip) skip |= manual_PreCallValidateCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ);
     return skip;
 }
 
@@ -4215,7 +4285,7 @@ bool StatelessValidation::PreCallValidateCmdDispatchIndirect(
     VkDeviceSize                                offset) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdDispatchIndirect", "buffer", buffer);
-    skip |= manual_PreCallValidateCmdDispatchIndirect(commandBuffer, buffer, offset);
+    if (!skip) skip |= manual_PreCallValidateCmdDispatchIndirect(commandBuffer, buffer, offset);
     return skip;
 }
 
@@ -4257,18 +4327,18 @@ bool StatelessValidation::PreCallValidateCmdCopyImage(
     {
         for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
         {
-            skip |= validate_flags("vkCmdCopyImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdCopyImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
 
             // No xml-driven validation
 
-            skip |= validate_flags("vkCmdCopyImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdCopyImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
 
             // No xml-driven validation
 
             // No xml-driven validation
         }
     }
-    skip |= manual_PreCallValidateCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
+    if (!skip) skip |= manual_PreCallValidateCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
     return skip;
 }
 
@@ -4291,13 +4361,13 @@ bool StatelessValidation::PreCallValidateCmdBlitImage(
     {
         for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
         {
-            skip |= validate_flags("vkCmdBlitImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdBlitImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
 
-            skip |= validate_flags("vkCmdBlitImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdBlitImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
         }
     }
     skip |= validate_ranged_enum("vkCmdBlitImage", "filter", "VkFilter", AllVkFilterEnums, filter, "VUID-vkCmdBlitImage-filter-parameter");
-    skip |= manual_PreCallValidateCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
+    if (!skip) skip |= manual_PreCallValidateCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
     return skip;
 }
 
@@ -4317,14 +4387,14 @@ bool StatelessValidation::PreCallValidateCmdCopyBufferToImage(
     {
         for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
         {
-            skip |= validate_flags("vkCmdCopyBufferToImage", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdCopyBufferToImage", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
 
             // No xml-driven validation
 
             // No xml-driven validation
         }
     }
-    skip |= manual_PreCallValidateCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
+    if (!skip) skip |= manual_PreCallValidateCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
     return skip;
 }
 
@@ -4344,14 +4414,14 @@ bool StatelessValidation::PreCallValidateCmdCopyImageToBuffer(
     {
         for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
         {
-            skip |= validate_flags("vkCmdCopyImageToBuffer", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdCopyImageToBuffer", ParameterName("pRegions[%i].imageSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].imageSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
 
             // No xml-driven validation
 
             // No xml-driven validation
         }
     }
-    skip |= manual_PreCallValidateCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
+    if (!skip) skip |= manual_PreCallValidateCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
     return skip;
 }
 
@@ -4364,7 +4434,7 @@ bool StatelessValidation::PreCallValidateCmdUpdateBuffer(
     bool skip = false;
     skip |= validate_required_handle("vkCmdUpdateBuffer", "dstBuffer", dstBuffer);
     skip |= validate_array("vkCmdUpdateBuffer", "dataSize", "pData", dataSize, &pData, true, true, "VUID-vkCmdUpdateBuffer-dataSize-arraylength", "VUID-vkCmdUpdateBuffer-pData-parameter");
-    skip |= manual_PreCallValidateCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
+    if (!skip) skip |= manual_PreCallValidateCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
     return skip;
 }
 
@@ -4376,7 +4446,7 @@ bool StatelessValidation::PreCallValidateCmdFillBuffer(
     uint32_t                                    data) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdFillBuffer", "dstBuffer", dstBuffer);
-    skip |= manual_PreCallValidateCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
+    if (!skip) skip |= manual_PreCallValidateCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
     return skip;
 }
 
@@ -4400,7 +4470,7 @@ bool StatelessValidation::PreCallValidateCmdClearColorImage(
     {
         for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex)
         {
-            skip |= validate_flags("vkCmdClearColorImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true, false, "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdClearColorImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, kRequiredFlags, "VUID-VkImageSubresourceRange-aspectMask-parameter", "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
         }
     }
     return skip;
@@ -4426,7 +4496,7 @@ bool StatelessValidation::PreCallValidateCmdClearDepthStencilImage(
     {
         for (uint32_t rangeIndex = 0; rangeIndex < rangeCount; ++rangeIndex)
         {
-            skip |= validate_flags("vkCmdClearDepthStencilImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, true, false, "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdClearDepthStencilImage", ParameterName("pRanges[%i].aspectMask", ParameterName::IndexVector{ rangeIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRanges[rangeIndex].aspectMask, kRequiredFlags, "VUID-VkImageSubresourceRange-aspectMask-parameter", "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
         }
     }
     return skip;
@@ -4444,7 +4514,7 @@ bool StatelessValidation::PreCallValidateCmdClearAttachments(
     {
         for (uint32_t attachmentIndex = 0; attachmentIndex < attachmentCount; ++attachmentIndex)
         {
-            skip |= validate_flags("vkCmdClearAttachments", ParameterName("pAttachments[%i].aspectMask", ParameterName::IndexVector{ attachmentIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pAttachments[attachmentIndex].aspectMask, true, false, "VUID-VkClearAttachment-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdClearAttachments", ParameterName("pAttachments[%i].aspectMask", ParameterName::IndexVector{ attachmentIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pAttachments[attachmentIndex].aspectMask, kRequiredFlags, "VUID-VkClearAttachment-aspectMask-parameter", "VUID-VkClearAttachment-aspectMask-requiredbitmask");
 
             // No xml-driven validation
 
@@ -4461,7 +4531,7 @@ bool StatelessValidation::PreCallValidateCmdClearAttachments(
             // No xml-driven validation
         }
     }
-    skip |= manual_PreCallValidateCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
+    if (!skip) skip |= manual_PreCallValidateCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
     return skip;
 }
 
@@ -4483,11 +4553,11 @@ bool StatelessValidation::PreCallValidateCmdResolveImage(
     {
         for (uint32_t regionIndex = 0; regionIndex < regionCount; ++regionIndex)
         {
-            skip |= validate_flags("vkCmdResolveImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdResolveImage", ParameterName("pRegions[%i].srcSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].srcSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
 
             // No xml-driven validation
 
-            skip |= validate_flags("vkCmdResolveImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, true, false, "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdResolveImage", ParameterName("pRegions[%i].dstSubresource.aspectMask", ParameterName::IndexVector{ regionIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pRegions[regionIndex].dstSubresource.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceLayers-aspectMask-parameter", "VUID-VkImageSubresourceLayers-aspectMask-requiredbitmask");
 
             // No xml-driven validation
 
@@ -4503,7 +4573,7 @@ bool StatelessValidation::PreCallValidateCmdSetEvent(
     VkPipelineStageFlags                        stageMask) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdSetEvent", "event", event);
-    skip |= validate_flags("vkCmdSetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true, false, "VUID-vkCmdSetEvent-stageMask-requiredbitmask");
+    skip |= validate_flags("vkCmdSetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, kRequiredFlags, "VUID-vkCmdSetEvent-stageMask-parameter", "VUID-vkCmdSetEvent-stageMask-requiredbitmask");
     return skip;
 }
 
@@ -4513,7 +4583,7 @@ bool StatelessValidation::PreCallValidateCmdResetEvent(
     VkPipelineStageFlags                        stageMask) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdResetEvent", "event", event);
-    skip |= validate_flags("vkCmdResetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, true, false, "VUID-vkCmdResetEvent-stageMask-requiredbitmask");
+    skip |= validate_flags("vkCmdResetEvent", "stageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, stageMask, kRequiredFlags, "VUID-vkCmdResetEvent-stageMask-parameter", "VUID-vkCmdResetEvent-stageMask-requiredbitmask");
     return skip;
 }
 
@@ -4531,8 +4601,8 @@ bool StatelessValidation::PreCallValidateCmdWaitEvents(
     const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
     bool skip = false;
     skip |= validate_handle_array("vkCmdWaitEvents", "eventCount", "pEvents", eventCount, pEvents, true, true);
-    skip |= validate_flags("vkCmdWaitEvents", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true, false, "VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask");
-    skip |= validate_flags("vkCmdWaitEvents", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true, false, "VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask");
+    skip |= validate_flags("vkCmdWaitEvents", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, kRequiredFlags, "VUID-vkCmdWaitEvents-srcStageMask-parameter", "VUID-vkCmdWaitEvents-srcStageMask-requiredbitmask");
+    skip |= validate_flags("vkCmdWaitEvents", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, kRequiredFlags, "VUID-vkCmdWaitEvents-dstStageMask-parameter", "VUID-vkCmdWaitEvents-dstStageMask-requiredbitmask");
     skip |= validate_struct_type_array("vkCmdWaitEvents", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true, "VUID-VkMemoryBarrier-sType-sType", "VUID-vkCmdWaitEvents-pMemoryBarriers-parameter", kVUIDUndefined);
     if (pMemoryBarriers != NULL)
     {
@@ -4540,9 +4610,9 @@ bool StatelessValidation::PreCallValidateCmdWaitEvents(
         {
             skip |= validate_struct_pnext("vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkMemoryBarrier-pNext-pNext");
 
-            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false, false, "VUID-VkMemoryBarrier-srcAccessMask-parameter");
+            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, kOptionalFlags, "VUID-VkMemoryBarrier-srcAccessMask-parameter");
 
-            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false, false, "VUID-VkMemoryBarrier-dstAccessMask-parameter");
+            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, kOptionalFlags, "VUID-VkMemoryBarrier-dstAccessMask-parameter");
         }
     }
     skip |= validate_struct_type_array("vkCmdWaitEvents", "bufferMemoryBarrierCount", "pBufferMemoryBarriers", "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", bufferMemoryBarrierCount, pBufferMemoryBarriers, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, false, true, "VUID-VkBufferMemoryBarrier-sType-sType", "VUID-vkCmdWaitEvents-pBufferMemoryBarriers-parameter", kVUIDUndefined);
@@ -4552,9 +4622,9 @@ bool StatelessValidation::PreCallValidateCmdWaitEvents(
         {
             skip |= validate_struct_pnext("vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkBufferMemoryBarrier-pNext-pNext");
 
-            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false, false, "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter");
+            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, kOptionalFlags, "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter");
 
-            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false, false, "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter");
+            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, kOptionalFlags, "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter");
 
             skip |= validate_required_handle("vkCmdWaitEvents", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer);
         }
@@ -4568,9 +4638,9 @@ bool StatelessValidation::PreCallValidateCmdWaitEvents(
 
             skip |= validate_struct_pnext("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkSampleLocationsInfoEXT", pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, ARRAY_SIZE(allowed_structs_VkImageMemoryBarrier), allowed_structs_VkImageMemoryBarrier, GeneratedVulkanHeaderVersion, "VUID-VkImageMemoryBarrier-pNext-pNext");
 
-            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false, false, "VUID-VkImageMemoryBarrier-srcAccessMask-parameter");
+            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, kOptionalFlags, "VUID-VkImageMemoryBarrier-srcAccessMask-parameter");
 
-            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false, false, "VUID-VkImageMemoryBarrier-dstAccessMask-parameter");
+            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, kOptionalFlags, "VUID-VkImageMemoryBarrier-dstAccessMask-parameter");
 
             skip |= validate_ranged_enum("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].oldLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", AllVkImageLayoutEnums, pImageMemoryBarriers[imageMemoryBarrierIndex].oldLayout, "VUID-VkImageMemoryBarrier-oldLayout-parameter");
 
@@ -4578,7 +4648,7 @@ bool StatelessValidation::PreCallValidateCmdWaitEvents(
 
             skip |= validate_required_handle("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image);
 
-            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true, false, "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdWaitEvents", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceRange-aspectMask-parameter", "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
         }
     }
     return skip;
@@ -4596,9 +4666,9 @@ bool StatelessValidation::PreCallValidateCmdPipelineBarrier(
     uint32_t                                    imageMemoryBarrierCount,
     const VkImageMemoryBarrier*                 pImageMemoryBarriers) {
     bool skip = false;
-    skip |= validate_flags("vkCmdPipelineBarrier", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, true, false, "VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask");
-    skip |= validate_flags("vkCmdPipelineBarrier", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, true, false, "VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask");
-    skip |= validate_flags("vkCmdPipelineBarrier", "dependencyFlags", "VkDependencyFlagBits", AllVkDependencyFlagBits, dependencyFlags, false, false, "VUID-vkCmdPipelineBarrier-dependencyFlags-parameter");
+    skip |= validate_flags("vkCmdPipelineBarrier", "srcStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, srcStageMask, kRequiredFlags, "VUID-vkCmdPipelineBarrier-srcStageMask-parameter", "VUID-vkCmdPipelineBarrier-srcStageMask-requiredbitmask");
+    skip |= validate_flags("vkCmdPipelineBarrier", "dstStageMask", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, dstStageMask, kRequiredFlags, "VUID-vkCmdPipelineBarrier-dstStageMask-parameter", "VUID-vkCmdPipelineBarrier-dstStageMask-requiredbitmask");
+    skip |= validate_flags("vkCmdPipelineBarrier", "dependencyFlags", "VkDependencyFlagBits", AllVkDependencyFlagBits, dependencyFlags, kOptionalFlags, "VUID-vkCmdPipelineBarrier-dependencyFlags-parameter");
     skip |= validate_struct_type_array("vkCmdPipelineBarrier", "memoryBarrierCount", "pMemoryBarriers", "VK_STRUCTURE_TYPE_MEMORY_BARRIER", memoryBarrierCount, pMemoryBarriers, VK_STRUCTURE_TYPE_MEMORY_BARRIER, false, true, "VUID-VkMemoryBarrier-sType-sType", "VUID-vkCmdPipelineBarrier-pMemoryBarriers-parameter", kVUIDUndefined);
     if (pMemoryBarriers != NULL)
     {
@@ -4606,9 +4676,9 @@ bool StatelessValidation::PreCallValidateCmdPipelineBarrier(
         {
             skip |= validate_struct_pnext("vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].pNext", ParameterName::IndexVector{ memoryBarrierIndex }), NULL, pMemoryBarriers[memoryBarrierIndex].pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkMemoryBarrier-pNext-pNext");
 
-            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, false, false, "VUID-VkMemoryBarrier-srcAccessMask-parameter");
+            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].srcAccessMask, kOptionalFlags, "VUID-VkMemoryBarrier-srcAccessMask-parameter");
 
-            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, false, false, "VUID-VkMemoryBarrier-dstAccessMask-parameter");
+            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ memoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pMemoryBarriers[memoryBarrierIndex].dstAccessMask, kOptionalFlags, "VUID-VkMemoryBarrier-dstAccessMask-parameter");
         }
     }
     skip |= validate_struct_type_array("vkCmdPipelineBarrier", "bufferMemoryBarrierCount", "pBufferMemoryBarriers", "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER", bufferMemoryBarrierCount, pBufferMemoryBarriers, VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, false, true, "VUID-VkBufferMemoryBarrier-sType-sType", "VUID-vkCmdPipelineBarrier-pBufferMemoryBarriers-parameter", kVUIDUndefined);
@@ -4618,9 +4688,9 @@ bool StatelessValidation::PreCallValidateCmdPipelineBarrier(
         {
             skip |= validate_struct_pnext("vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].pNext", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), NULL, pBufferMemoryBarriers[bufferMemoryBarrierIndex].pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkBufferMemoryBarrier-pNext-pNext");
 
-            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, false, false, "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter");
+            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].srcAccessMask, kOptionalFlags, "VUID-VkBufferMemoryBarrier-srcAccessMask-parameter");
 
-            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, false, false, "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter");
+            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pBufferMemoryBarriers[bufferMemoryBarrierIndex].dstAccessMask, kOptionalFlags, "VUID-VkBufferMemoryBarrier-dstAccessMask-parameter");
 
             skip |= validate_required_handle("vkCmdPipelineBarrier", ParameterName("pBufferMemoryBarriers[%i].buffer", ParameterName::IndexVector{ bufferMemoryBarrierIndex }), pBufferMemoryBarriers[bufferMemoryBarrierIndex].buffer);
         }
@@ -4634,9 +4704,9 @@ bool StatelessValidation::PreCallValidateCmdPipelineBarrier(
 
             skip |= validate_struct_pnext("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].pNext", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkSampleLocationsInfoEXT", pImageMemoryBarriers[imageMemoryBarrierIndex].pNext, ARRAY_SIZE(allowed_structs_VkImageMemoryBarrier), allowed_structs_VkImageMemoryBarrier, GeneratedVulkanHeaderVersion, "VUID-VkImageMemoryBarrier-pNext-pNext");
 
-            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, false, false, "VUID-VkImageMemoryBarrier-srcAccessMask-parameter");
+            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].srcAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].srcAccessMask, kOptionalFlags, "VUID-VkImageMemoryBarrier-srcAccessMask-parameter");
 
-            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, false, false, "VUID-VkImageMemoryBarrier-dstAccessMask-parameter");
+            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].dstAccessMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].dstAccessMask, kOptionalFlags, "VUID-VkImageMemoryBarrier-dstAccessMask-parameter");
 
             skip |= validate_ranged_enum("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].oldLayout", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageLayout", AllVkImageLayoutEnums, pImageMemoryBarriers[imageMemoryBarrierIndex].oldLayout, "VUID-VkImageMemoryBarrier-oldLayout-parameter");
 
@@ -4644,7 +4714,7 @@ bool StatelessValidation::PreCallValidateCmdPipelineBarrier(
 
             skip |= validate_required_handle("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].image", ParameterName::IndexVector{ imageMemoryBarrierIndex }), pImageMemoryBarriers[imageMemoryBarrierIndex].image);
 
-            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, true, false, "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
+            skip |= validate_flags("vkCmdPipelineBarrier", ParameterName("pImageMemoryBarriers[%i].subresourceRange.aspectMask", ParameterName::IndexVector{ imageMemoryBarrierIndex }), "VkImageAspectFlagBits", AllVkImageAspectFlagBits, pImageMemoryBarriers[imageMemoryBarrierIndex].subresourceRange.aspectMask, kRequiredFlags, "VUID-VkImageSubresourceRange-aspectMask-parameter", "VUID-VkImageSubresourceRange-aspectMask-requiredbitmask");
         }
     }
     return skip;
@@ -4657,7 +4727,7 @@ bool StatelessValidation::PreCallValidateCmdBeginQuery(
     VkQueryControlFlags                         flags) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdBeginQuery", "queryPool", queryPool);
-    skip |= validate_flags("vkCmdBeginQuery", "flags", "VkQueryControlFlagBits", AllVkQueryControlFlagBits, flags, false, false, "VUID-vkCmdBeginQuery-flags-parameter");
+    skip |= validate_flags("vkCmdBeginQuery", "flags", "VkQueryControlFlagBits", AllVkQueryControlFlagBits, flags, kOptionalFlags, "VUID-vkCmdBeginQuery-flags-parameter");
     return skip;
 }
 
@@ -4686,7 +4756,7 @@ bool StatelessValidation::PreCallValidateCmdWriteTimestamp(
     VkQueryPool                                 queryPool,
     uint32_t                                    query) {
     bool skip = false;
-    skip |= validate_flags("vkCmdWriteTimestamp", "pipelineStage", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pipelineStage, true, true, "VUID-vkCmdWriteTimestamp-pipelineStage-parameter");
+    skip |= validate_flags("vkCmdWriteTimestamp", "pipelineStage", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pipelineStage, kRequiredSingleBit, "VUID-vkCmdWriteTimestamp-pipelineStage-parameter", "VUID-vkCmdWriteTimestamp-pipelineStage-parameter");
     skip |= validate_required_handle("vkCmdWriteTimestamp", "queryPool", queryPool);
     return skip;
 }
@@ -4703,7 +4773,7 @@ bool StatelessValidation::PreCallValidateCmdCopyQueryPoolResults(
     bool skip = false;
     skip |= validate_required_handle("vkCmdCopyQueryPoolResults", "queryPool", queryPool);
     skip |= validate_required_handle("vkCmdCopyQueryPoolResults", "dstBuffer", dstBuffer);
-    skip |= validate_flags("vkCmdCopyQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, false, false, "VUID-vkCmdCopyQueryPoolResults-flags-parameter");
+    skip |= validate_flags("vkCmdCopyQueryPoolResults", "flags", "VkQueryResultFlagBits", AllVkQueryResultFlagBits, flags, kOptionalFlags, "VUID-vkCmdCopyQueryPoolResults-flags-parameter");
     return skip;
 }
 
@@ -4716,7 +4786,7 @@ bool StatelessValidation::PreCallValidateCmdPushConstants(
     const void*                                 pValues) {
     bool skip = false;
     skip |= validate_required_handle("vkCmdPushConstants", "layout", layout);
-    skip |= validate_flags("vkCmdPushConstants", "stageFlags", "VkShaderStageFlagBits", AllVkShaderStageFlagBits, stageFlags, true, false, "VUID-vkCmdPushConstants-stageFlags-requiredbitmask");
+    skip |= validate_flags("vkCmdPushConstants", "stageFlags", "VkShaderStageFlagBits", AllVkShaderStageFlagBits, stageFlags, kRequiredFlags, "VUID-vkCmdPushConstants-stageFlags-parameter", "VUID-vkCmdPushConstants-stageFlags-requiredbitmask");
     skip |= validate_array("vkCmdPushConstants", "size", "pValues", size, &pValues, true, true, "VUID-vkCmdPushConstants-size-arraylength", "VUID-vkCmdPushConstants-pValues-parameter");
     return skip;
 }
@@ -4991,9 +5061,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2
 
         skip |= validate_ranged_enum("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pImageFormatInfo->tiling, "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pImageFormatInfo->usage, true, false, "VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask");
+        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pImageFormatInfo->usage, kRequiredFlags, "VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter", "VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask");
 
-        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageFormatInfo->flags, false, false, "VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageFormatInfo->flags, kOptionalFlags, "VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType");
     if (pImageFormatProperties != NULL)
@@ -5046,9 +5116,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceSparseImageFormatPrope
 
         skip |= validate_ranged_enum("vkGetPhysicalDeviceSparseImageFormatProperties2", "pFormatInfo->type", "VkImageType", AllVkImageTypeEnums, pFormatInfo->type, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2", "pFormatInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pFormatInfo->samples, true, true, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2", "pFormatInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pFormatInfo->samples, kRequiredSingleBit, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter", "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2", "pFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pFormatInfo->usage, true, false, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask");
+        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2", "pFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pFormatInfo->usage, kRequiredFlags, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter", "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask");
 
         skip |= validate_ranged_enum("vkGetPhysicalDeviceSparseImageFormatProperties2", "pFormatInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pFormatInfo->tiling, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter");
     }
@@ -5083,7 +5153,7 @@ bool StatelessValidation::PreCallValidateGetDeviceQueue2(
     {
         skip |= validate_struct_pnext("vkGetDeviceQueue2", "pQueueInfo->pNext", NULL, pQueueInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkDeviceQueueInfo2-pNext-pNext");
 
-        skip |= validate_flags("vkGetDeviceQueue2", "pQueueInfo->flags", "VkDeviceQueueCreateFlagBits", AllVkDeviceQueueCreateFlagBits, pQueueInfo->flags, true, false, "VUID-VkDeviceQueueInfo2-flags-requiredbitmask");
+        skip |= validate_flags("vkGetDeviceQueue2", "pQueueInfo->flags", "VkDeviceQueueCreateFlagBits", AllVkDeviceQueueCreateFlagBits, pQueueInfo->flags, kRequiredFlags, "VUID-VkDeviceQueueInfo2-flags-parameter", "VUID-VkDeviceQueueInfo2-flags-requiredbitmask");
     }
     skip |= validate_required_pointer("vkGetDeviceQueue2", "pQueue", pQueue, "VUID-vkGetDeviceQueue2-pQueue-parameter");
     return skip;
@@ -5274,11 +5344,11 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalBufferProperti
     {
         skip |= validate_struct_pnext("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferInfo->pNext", NULL, pExternalBufferInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pExternalBufferInfo->flags, false, false, "VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pExternalBufferInfo->flags, kOptionalFlags, "VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pExternalBufferInfo->usage, true, false, "VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pExternalBufferInfo->usage, kRequiredFlags, "VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter", "VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pExternalBufferInfo->handleType, true, true, "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pExternalBufferInfo->handleType, kRequiredSingleBit, "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter", "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceExternalBufferProperties", "pExternalBufferProperties", "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES", pExternalBufferProperties, VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, true, "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter", "VUID-VkExternalBufferProperties-sType-sType");
     if (pExternalBufferProperties != NULL)
@@ -5298,7 +5368,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalFencePropertie
     {
         skip |= validate_struct_pnext("vkGetPhysicalDeviceExternalFenceProperties", "pExternalFenceInfo->pNext", NULL, pExternalFenceInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalFenceProperties", "pExternalFenceInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pExternalFenceInfo->handleType, true, true, "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalFenceProperties", "pExternalFenceInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pExternalFenceInfo->handleType, kRequiredSingleBit, "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter", "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceExternalFenceProperties", "pExternalFenceProperties", "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES", pExternalFenceProperties, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, true, "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter", "VUID-VkExternalFenceProperties-sType-sType");
     if (pExternalFenceProperties != NULL)
@@ -5318,7 +5388,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalSemaphorePrope
     {
         skip |= validate_struct_pnext("vkGetPhysicalDeviceExternalSemaphoreProperties", "pExternalSemaphoreInfo->pNext", NULL, pExternalSemaphoreInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalSemaphoreProperties", "pExternalSemaphoreInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pExternalSemaphoreInfo->handleType, true, true, "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalSemaphoreProperties", "pExternalSemaphoreInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pExternalSemaphoreInfo->handleType, kRequiredSingleBit, "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter", "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceExternalSemaphoreProperties", "pExternalSemaphoreProperties", "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES", pExternalSemaphoreProperties, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, true, "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter", "VUID-VkExternalSemaphoreProperties-sType-sType");
     if (pExternalSemaphoreProperties != NULL)
@@ -5340,7 +5410,7 @@ bool StatelessValidation::PreCallValidateGetDescriptorSetLayoutSupport(
 
         skip |= validate_struct_pnext("vkGetDescriptorSetLayoutSupport", "pCreateInfo->pNext", "VkDescriptorSetLayoutBindingFlagsCreateInfoEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkDescriptorSetLayoutCreateInfo), allowed_structs_VkDescriptorSetLayoutCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetDescriptorSetLayoutSupport", "pCreateInfo->flags", "VkDescriptorSetLayoutCreateFlagBits", AllVkDescriptorSetLayoutCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter");
+        skip |= validate_flags("vkGetDescriptorSetLayoutSupport", "pCreateInfo->flags", "VkDescriptorSetLayoutCreateFlagBits", AllVkDescriptorSetLayoutCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter");
 
         skip |= validate_array("vkGetDescriptorSetLayoutSupport", "pCreateInfo->bindingCount", "pCreateInfo->pBindings", pCreateInfo->bindingCount, &pCreateInfo->pBindings, false, true, kVUIDUndefined, "VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter");
 
@@ -5466,7 +5536,7 @@ bool StatelessValidation::PreCallValidateCreateSwapchainKHR(
 
         skip |= validate_struct_pnext("vkCreateSwapchainKHR", "pCreateInfo->pNext", "VkDeviceGroupSwapchainCreateInfoKHR, VkImageFormatListCreateInfoKHR, VkSurfaceFullScreenExclusiveInfoEXT, VkSurfaceFullScreenExclusiveWin32InfoEXT, VkSwapchainCounterCreateInfoEXT, VkSwapchainDisplayNativeHdrCreateInfoAMD", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkSwapchainCreateInfoKHR), allowed_structs_VkSwapchainCreateInfoKHR, GeneratedVulkanHeaderVersion, "VUID-VkSwapchainCreateInfoKHR-pNext-pNext");
 
-        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->flags", "VkSwapchainCreateFlagBitsKHR", AllVkSwapchainCreateFlagBitsKHR, pCreateInfo->flags, false, false, "VUID-VkSwapchainCreateInfoKHR-flags-parameter");
+        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->flags", "VkSwapchainCreateFlagBitsKHR", AllVkSwapchainCreateFlagBitsKHR, pCreateInfo->flags, kOptionalFlags, "VUID-VkSwapchainCreateInfoKHR-flags-parameter");
 
         skip |= validate_required_handle("vkCreateSwapchainKHR", "pCreateInfo->surface", pCreateInfo->surface);
 
@@ -5476,13 +5546,13 @@ bool StatelessValidation::PreCallValidateCreateSwapchainKHR(
 
         // No xml-driven validation
 
-        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->imageUsage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->imageUsage, true, false, "VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask");
+        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->imageUsage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfo->imageUsage, kRequiredFlags, "VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter", "VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask");
 
         skip |= validate_ranged_enum("vkCreateSwapchainKHR", "pCreateInfo->imageSharingMode", "VkSharingMode", AllVkSharingModeEnums, pCreateInfo->imageSharingMode, "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter");
 
-        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->preTransform", "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfo->preTransform, true, true, "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter");
+        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->preTransform", "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfo->preTransform, kRequiredSingleBit, "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter", "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter");
 
-        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->compositeAlpha", "VkCompositeAlphaFlagBitsKHR", AllVkCompositeAlphaFlagBitsKHR, pCreateInfo->compositeAlpha, true, true, "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter");
+        skip |= validate_flags("vkCreateSwapchainKHR", "pCreateInfo->compositeAlpha", "VkCompositeAlphaFlagBitsKHR", AllVkCompositeAlphaFlagBitsKHR, pCreateInfo->compositeAlpha, kRequiredSingleBit, "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter", "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter");
 
         skip |= validate_ranged_enum("vkCreateSwapchainKHR", "pCreateInfo->presentMode", "VkPresentModeKHR", AllVkPresentModeKHREnums, pCreateInfo->presentMode, "VUID-VkSwapchainCreateInfoKHR-presentMode-parameter");
 
@@ -5509,7 +5579,7 @@ bool StatelessValidation::PreCallValidateCreateSwapchainKHR(
         }
     }
     skip |= validate_required_pointer("vkCreateSwapchainKHR", "pSwapchain", pSwapchain, "VUID-vkCreateSwapchainKHR-pSwapchain-parameter");
-    skip |= manual_PreCallValidateCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+    if (!skip) skip |= manual_PreCallValidateCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
     return skip;
 }
 
@@ -5592,7 +5662,7 @@ bool StatelessValidation::PreCallValidateQueuePresentKHR(
 
         skip |= validate_array("vkQueuePresentKHR", "pPresentInfo->swapchainCount", "pPresentInfo->pResults", pPresentInfo->swapchainCount, &pPresentInfo->pResults, true, false, "VUID-VkPresentInfoKHR-swapchainCount-arraylength", "VUID-VkPresentInfoKHR-pResults-parameter");
     }
-    skip |= manual_PreCallValidateQueuePresentKHR(queue, pPresentInfo);
+    if (!skip) skip |= manual_PreCallValidateQueuePresentKHR(queue, pPresentInfo);
     return skip;
 }
 
@@ -5797,9 +5867,9 @@ bool StatelessValidation::PreCallValidateCreateDisplayPlaneSurfaceKHR(
 
         skip |= validate_required_handle("vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->displayMode", pCreateInfo->displayMode);
 
-        skip |= validate_flags("vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->transform", "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfo->transform, true, true, "VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter");
+        skip |= validate_flags("vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->transform", "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfo->transform, kRequiredSingleBit, "VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter", "VUID-VkDisplaySurfaceCreateInfoKHR-transform-parameter");
 
-        skip |= validate_flags("vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->alphaMode", "VkDisplayPlaneAlphaFlagBitsKHR", AllVkDisplayPlaneAlphaFlagBitsKHR, pCreateInfo->alphaMode, true, true, "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter");
+        skip |= validate_flags("vkCreateDisplayPlaneSurfaceKHR", "pCreateInfo->alphaMode", "VkDisplayPlaneAlphaFlagBitsKHR", AllVkDisplayPlaneAlphaFlagBitsKHR, pCreateInfo->alphaMode, kRequiredSingleBit, "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter", "VUID-VkDisplaySurfaceCreateInfoKHR-alphaMode-parameter");
 
         // No xml-driven validation
     }
@@ -5848,7 +5918,7 @@ bool StatelessValidation::PreCallValidateCreateSharedSwapchainsKHR(
 
             skip |= validate_struct_pnext("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ swapchainIndex }), "VkDeviceGroupSwapchainCreateInfoKHR, VkImageFormatListCreateInfoKHR, VkSurfaceFullScreenExclusiveInfoEXT, VkSurfaceFullScreenExclusiveWin32InfoEXT, VkSwapchainCounterCreateInfoEXT, VkSwapchainDisplayNativeHdrCreateInfoAMD", pCreateInfos[swapchainIndex].pNext, ARRAY_SIZE(allowed_structs_VkSwapchainCreateInfoKHR), allowed_structs_VkSwapchainCreateInfoKHR, GeneratedVulkanHeaderVersion, "VUID-VkSwapchainCreateInfoKHR-pNext-pNext");
 
-            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ swapchainIndex }), "VkSwapchainCreateFlagBitsKHR", AllVkSwapchainCreateFlagBitsKHR, pCreateInfos[swapchainIndex].flags, false, false, "VUID-VkSwapchainCreateInfoKHR-flags-parameter");
+            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ swapchainIndex }), "VkSwapchainCreateFlagBitsKHR", AllVkSwapchainCreateFlagBitsKHR, pCreateInfos[swapchainIndex].flags, kOptionalFlags, "VUID-VkSwapchainCreateInfoKHR-flags-parameter");
 
             skip |= validate_required_handle("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].surface", ParameterName::IndexVector{ swapchainIndex }), pCreateInfos[swapchainIndex].surface);
 
@@ -5858,13 +5928,13 @@ bool StatelessValidation::PreCallValidateCreateSharedSwapchainsKHR(
 
             // No xml-driven validation
 
-            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].imageUsage", ParameterName::IndexVector{ swapchainIndex }), "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfos[swapchainIndex].imageUsage, true, false, "VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask");
+            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].imageUsage", ParameterName::IndexVector{ swapchainIndex }), "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pCreateInfos[swapchainIndex].imageUsage, kRequiredFlags, "VUID-VkSwapchainCreateInfoKHR-imageUsage-parameter", "VUID-VkSwapchainCreateInfoKHR-imageUsage-requiredbitmask");
 
             skip |= validate_ranged_enum("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].imageSharingMode", ParameterName::IndexVector{ swapchainIndex }), "VkSharingMode", AllVkSharingModeEnums, pCreateInfos[swapchainIndex].imageSharingMode, "VUID-VkSwapchainCreateInfoKHR-imageSharingMode-parameter");
 
-            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].preTransform", ParameterName::IndexVector{ swapchainIndex }), "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfos[swapchainIndex].preTransform, true, true, "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter");
+            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].preTransform", ParameterName::IndexVector{ swapchainIndex }), "VkSurfaceTransformFlagBitsKHR", AllVkSurfaceTransformFlagBitsKHR, pCreateInfos[swapchainIndex].preTransform, kRequiredSingleBit, "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter", "VUID-VkSwapchainCreateInfoKHR-preTransform-parameter");
 
-            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].compositeAlpha", ParameterName::IndexVector{ swapchainIndex }), "VkCompositeAlphaFlagBitsKHR", AllVkCompositeAlphaFlagBitsKHR, pCreateInfos[swapchainIndex].compositeAlpha, true, true, "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter");
+            skip |= validate_flags("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].compositeAlpha", ParameterName::IndexVector{ swapchainIndex }), "VkCompositeAlphaFlagBitsKHR", AllVkCompositeAlphaFlagBitsKHR, pCreateInfos[swapchainIndex].compositeAlpha, kRequiredSingleBit, "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter", "VUID-VkSwapchainCreateInfoKHR-compositeAlpha-parameter");
 
             skip |= validate_ranged_enum("vkCreateSharedSwapchainsKHR", ParameterName("pCreateInfos[%i].presentMode", ParameterName::IndexVector{ swapchainIndex }), "VkPresentModeKHR", AllVkPresentModeKHREnums, pCreateInfos[swapchainIndex].presentMode, "VUID-VkSwapchainCreateInfoKHR-presentMode-parameter");
 
@@ -6217,9 +6287,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceImageFormatProperties2
 
         skip |= validate_ranged_enum("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pImageFormatInfo->tiling, "VUID-VkPhysicalDeviceImageFormatInfo2-tiling-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pImageFormatInfo->usage, true, false, "VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask");
+        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pImageFormatInfo->usage, kRequiredFlags, "VUID-VkPhysicalDeviceImageFormatInfo2-usage-parameter", "VUID-VkPhysicalDeviceImageFormatInfo2-usage-requiredbitmask");
 
-        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageFormatInfo->flags, false, false, "VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatInfo->flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, pImageFormatInfo->flags, kOptionalFlags, "VUID-VkPhysicalDeviceImageFormatInfo2-flags-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceImageFormatProperties2KHR", "pImageFormatProperties", "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2", pImageFormatProperties, VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, true, "VUID-vkGetPhysicalDeviceImageFormatProperties2-pImageFormatProperties-parameter", "VUID-VkImageFormatProperties2-sType-sType");
     if (pImageFormatProperties != NULL)
@@ -6275,9 +6345,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceSparseImageFormatPrope
 
         skip |= validate_ranged_enum("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->type", "VkImageType", AllVkImageTypeEnums, pFormatInfo->type, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-type-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pFormatInfo->samples, true, true, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pFormatInfo->samples, kRequiredSingleBit, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter", "VUID-VkPhysicalDeviceSparseImageFormatInfo2-samples-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pFormatInfo->usage, true, false, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask");
+        skip |= validate_flags("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, pFormatInfo->usage, kRequiredFlags, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter", "VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask");
 
         skip |= validate_ranged_enum("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", "pFormatInfo->tiling", "VkImageTiling", AllVkImageTilingEnums, pFormatInfo->tiling, "VUID-VkPhysicalDeviceSparseImageFormatInfo2-tiling-parameter");
     }
@@ -6329,7 +6399,7 @@ bool StatelessValidation::PreCallValidateCmdDispatchBaseKHR(
     if (!device_extensions.vk_khr_device_group_creation) skip |= OutputExtensionError("vkCmdDispatchBaseKHR", VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME);
     if (!device_extensions.vk_khr_device_group) skip |= OutputExtensionError("vkCmdDispatchBaseKHR", VK_KHR_DEVICE_GROUP_EXTENSION_NAME);
     // No xml-driven validation
-    skip |= manual_PreCallValidateCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+    if (!skip) skip |= manual_PreCallValidateCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
     return skip;
 }
 
@@ -6381,11 +6451,11 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalBufferProperti
     {
         skip |= validate_struct_pnext("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->pNext", NULL, pExternalBufferInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPhysicalDeviceExternalBufferInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pExternalBufferInfo->flags, false, false, "VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->flags", "VkBufferCreateFlagBits", AllVkBufferCreateFlagBits, pExternalBufferInfo->flags, kOptionalFlags, "VUID-VkPhysicalDeviceExternalBufferInfo-flags-parameter");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pExternalBufferInfo->usage, true, false, "VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->usage", "VkBufferUsageFlagBits", AllVkBufferUsageFlagBits, pExternalBufferInfo->usage, kRequiredFlags, "VUID-VkPhysicalDeviceExternalBufferInfo-usage-parameter", "VUID-VkPhysicalDeviceExternalBufferInfo-usage-requiredbitmask");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pExternalBufferInfo->handleType, true, true, "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pExternalBufferInfo->handleType, kRequiredSingleBit, "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter", "VUID-VkPhysicalDeviceExternalBufferInfo-handleType-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceExternalBufferPropertiesKHR", "pExternalBufferProperties", "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES", pExternalBufferProperties, VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, true, "VUID-vkGetPhysicalDeviceExternalBufferProperties-pExternalBufferProperties-parameter", "VUID-VkExternalBufferProperties-sType-sType");
     if (pExternalBufferProperties != NULL)
@@ -6415,7 +6485,7 @@ bool StatelessValidation::PreCallValidateGetMemoryWin32HandleKHR(
 
         skip |= validate_required_handle("vkGetMemoryWin32HandleKHR", "pGetWin32HandleInfo->memory", pGetWin32HandleInfo->memory);
 
-        skip |= validate_flags("vkGetMemoryWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pGetWin32HandleInfo->handleType, true, true, "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkGetMemoryWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pGetWin32HandleInfo->handleType, kRequiredSingleBit, "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter", "VUID-VkMemoryGetWin32HandleInfoKHR-handleType-parameter");
     }
     skip |= validate_required_pointer("vkGetMemoryWin32HandleKHR", "pHandle", pHandle, "VUID-vkGetMemoryWin32HandleKHR-pHandle-parameter");
     return skip;
@@ -6429,7 +6499,7 @@ bool StatelessValidation::PreCallValidateGetMemoryWin32HandlePropertiesKHR(
     bool skip = false;
     if (!device_extensions.vk_khr_external_memory) skip |= OutputExtensionError("vkGetMemoryWin32HandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
     if (!device_extensions.vk_khr_external_memory_win32) skip |= OutputExtensionError("vkGetMemoryWin32HandlePropertiesKHR", VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
-    skip |= validate_flags("vkGetMemoryWin32HandlePropertiesKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, handleType, true, true, "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter");
+    skip |= validate_flags("vkGetMemoryWin32HandlePropertiesKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, handleType, kRequiredSingleBit, "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter", "VUID-vkGetMemoryWin32HandlePropertiesKHR-handleType-parameter");
     skip |= validate_struct_type("vkGetMemoryWin32HandlePropertiesKHR", "pMemoryWin32HandleProperties", "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR", pMemoryWin32HandleProperties, VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR, true, "VUID-vkGetMemoryWin32HandlePropertiesKHR-pMemoryWin32HandleProperties-parameter", "VUID-VkMemoryWin32HandlePropertiesKHR-sType-sType");
     if (pMemoryWin32HandleProperties != NULL)
     {
@@ -6454,7 +6524,7 @@ bool StatelessValidation::PreCallValidateGetMemoryFdKHR(
 
         skip |= validate_required_handle("vkGetMemoryFdKHR", "pGetFdInfo->memory", pGetFdInfo->memory);
 
-        skip |= validate_flags("vkGetMemoryFdKHR", "pGetFdInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pGetFdInfo->handleType, true, true, "VUID-VkMemoryGetFdInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkGetMemoryFdKHR", "pGetFdInfo->handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, pGetFdInfo->handleType, kRequiredSingleBit, "VUID-VkMemoryGetFdInfoKHR-handleType-parameter", "VUID-VkMemoryGetFdInfoKHR-handleType-parameter");
     }
     skip |= validate_required_pointer("vkGetMemoryFdKHR", "pFd", pFd, "VUID-vkGetMemoryFdKHR-pFd-parameter");
     return skip;
@@ -6468,7 +6538,7 @@ bool StatelessValidation::PreCallValidateGetMemoryFdPropertiesKHR(
     bool skip = false;
     if (!device_extensions.vk_khr_external_memory) skip |= OutputExtensionError("vkGetMemoryFdPropertiesKHR", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
     if (!device_extensions.vk_khr_external_memory_fd) skip |= OutputExtensionError("vkGetMemoryFdPropertiesKHR", VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
-    skip |= validate_flags("vkGetMemoryFdPropertiesKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, handleType, true, true, "VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter");
+    skip |= validate_flags("vkGetMemoryFdPropertiesKHR", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, handleType, kRequiredSingleBit, "VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter", "VUID-vkGetMemoryFdPropertiesKHR-handleType-parameter");
     skip |= validate_struct_type("vkGetMemoryFdPropertiesKHR", "pMemoryFdProperties", "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR", pMemoryFdProperties, VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR, true, "VUID-vkGetMemoryFdPropertiesKHR-pMemoryFdProperties-parameter", "VUID-VkMemoryFdPropertiesKHR-sType-sType");
     if (pMemoryFdProperties != NULL)
     {
@@ -6495,7 +6565,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalSemaphorePrope
     {
         skip |= validate_struct_pnext("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreInfo->pNext", NULL, pExternalSemaphoreInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pExternalSemaphoreInfo->handleType, true, true, "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pExternalSemaphoreInfo->handleType, kRequiredSingleBit, "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter", "VUID-VkPhysicalDeviceExternalSemaphoreInfo-handleType-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", "pExternalSemaphoreProperties", "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES", pExternalSemaphoreProperties, VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, true, "VUID-vkGetPhysicalDeviceExternalSemaphoreProperties-pExternalSemaphoreProperties-parameter", "VUID-VkExternalSemaphoreProperties-sType-sType");
     if (pExternalSemaphoreProperties != NULL)
@@ -6524,9 +6594,9 @@ bool StatelessValidation::PreCallValidateImportSemaphoreWin32HandleKHR(
 
         skip |= validate_required_handle("vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->semaphore", pImportSemaphoreWin32HandleInfo->semaphore);
 
-        skip |= validate_flags("vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->flags", "VkSemaphoreImportFlagBits", AllVkSemaphoreImportFlagBits, pImportSemaphoreWin32HandleInfo->flags, false, false, "VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter");
+        skip |= validate_flags("vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->flags", "VkSemaphoreImportFlagBits", AllVkSemaphoreImportFlagBits, pImportSemaphoreWin32HandleInfo->flags, kOptionalFlags, "VUID-VkImportSemaphoreWin32HandleInfoKHR-flags-parameter");
 
-        skip |= validate_flags("vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pImportSemaphoreWin32HandleInfo->handleType, false, true, "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkImportSemaphoreWin32HandleKHR", "pImportSemaphoreWin32HandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pImportSemaphoreWin32HandleInfo->handleType, kOptionalSingleBit, "VUID-VkImportSemaphoreWin32HandleInfoKHR-handleType-parameter");
     }
     return skip;
 }
@@ -6545,7 +6615,7 @@ bool StatelessValidation::PreCallValidateGetSemaphoreWin32HandleKHR(
 
         skip |= validate_required_handle("vkGetSemaphoreWin32HandleKHR", "pGetWin32HandleInfo->semaphore", pGetWin32HandleInfo->semaphore);
 
-        skip |= validate_flags("vkGetSemaphoreWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pGetWin32HandleInfo->handleType, true, true, "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkGetSemaphoreWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pGetWin32HandleInfo->handleType, kRequiredSingleBit, "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter", "VUID-VkSemaphoreGetWin32HandleInfoKHR-handleType-parameter");
     }
     skip |= validate_required_pointer("vkGetSemaphoreWin32HandleKHR", "pHandle", pHandle, "VUID-vkGetSemaphoreWin32HandleKHR-pHandle-parameter");
     return skip;
@@ -6566,9 +6636,9 @@ bool StatelessValidation::PreCallValidateImportSemaphoreFdKHR(
 
         skip |= validate_required_handle("vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->semaphore", pImportSemaphoreFdInfo->semaphore);
 
-        skip |= validate_flags("vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->flags", "VkSemaphoreImportFlagBits", AllVkSemaphoreImportFlagBits, pImportSemaphoreFdInfo->flags, false, false, "VUID-VkImportSemaphoreFdInfoKHR-flags-parameter");
+        skip |= validate_flags("vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->flags", "VkSemaphoreImportFlagBits", AllVkSemaphoreImportFlagBits, pImportSemaphoreFdInfo->flags, kOptionalFlags, "VUID-VkImportSemaphoreFdInfoKHR-flags-parameter");
 
-        skip |= validate_flags("vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pImportSemaphoreFdInfo->handleType, true, true, "VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkImportSemaphoreFdKHR", "pImportSemaphoreFdInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pImportSemaphoreFdInfo->handleType, kRequiredSingleBit, "VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter", "VUID-VkImportSemaphoreFdInfoKHR-handleType-parameter");
     }
     return skip;
 }
@@ -6587,7 +6657,7 @@ bool StatelessValidation::PreCallValidateGetSemaphoreFdKHR(
 
         skip |= validate_required_handle("vkGetSemaphoreFdKHR", "pGetFdInfo->semaphore", pGetFdInfo->semaphore);
 
-        skip |= validate_flags("vkGetSemaphoreFdKHR", "pGetFdInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pGetFdInfo->handleType, true, true, "VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkGetSemaphoreFdKHR", "pGetFdInfo->handleType", "VkExternalSemaphoreHandleTypeFlagBits", AllVkExternalSemaphoreHandleTypeFlagBits, pGetFdInfo->handleType, kRequiredSingleBit, "VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter", "VUID-VkSemaphoreGetFdInfoKHR-handleType-parameter");
     }
     skip |= validate_required_pointer("vkGetSemaphoreFdKHR", "pFd", pFd, "VUID-vkGetSemaphoreFdKHR-pFd-parameter");
     return skip;
@@ -6759,11 +6829,11 @@ bool StatelessValidation::PreCallValidateCreateRenderPass2KHR(
         {
             for (uint32_t attachmentIndex = 0; attachmentIndex < pCreateInfo->attachmentCount; ++attachmentIndex)
             {
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pAttachments[%i].flags", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentDescriptionFlagBits", AllVkAttachmentDescriptionFlagBits, pCreateInfo->pAttachments[attachmentIndex].flags, false, false, "VUID-VkAttachmentDescription2KHR-flags-parameter");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pAttachments[%i].flags", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentDescriptionFlagBits", AllVkAttachmentDescriptionFlagBits, pCreateInfo->pAttachments[attachmentIndex].flags, kOptionalFlags, "VUID-VkAttachmentDescription2KHR-flags-parameter");
 
                 skip |= validate_ranged_enum("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pAttachments[%i].format", ParameterName::IndexVector{ attachmentIndex }), "VkFormat", AllVkFormatEnums, pCreateInfo->pAttachments[attachmentIndex].format, "VUID-VkAttachmentDescription2KHR-format-parameter");
 
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pAttachments[%i].samples", ParameterName::IndexVector{ attachmentIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->pAttachments[attachmentIndex].samples, true, true, "VUID-VkAttachmentDescription2KHR-samples-parameter");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pAttachments[%i].samples", ParameterName::IndexVector{ attachmentIndex }), "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfo->pAttachments[attachmentIndex].samples, kRequiredSingleBit, "VUID-VkAttachmentDescription2KHR-samples-parameter", "VUID-VkAttachmentDescription2KHR-samples-parameter");
 
                 skip |= validate_ranged_enum("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pAttachments[%i].loadOp", ParameterName::IndexVector{ attachmentIndex }), "VkAttachmentLoadOp", AllVkAttachmentLoadOpEnums, pCreateInfo->pAttachments[attachmentIndex].loadOp, "VUID-VkAttachmentDescription2KHR-loadOp-parameter");
 
@@ -6785,7 +6855,7 @@ bool StatelessValidation::PreCallValidateCreateRenderPass2KHR(
         {
             for (uint32_t subpassIndex = 0; subpassIndex < pCreateInfo->subpassCount; ++subpassIndex)
             {
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pSubpasses[%i].flags", ParameterName::IndexVector{ subpassIndex }), "VkSubpassDescriptionFlagBits", AllVkSubpassDescriptionFlagBits, pCreateInfo->pSubpasses[subpassIndex].flags, false, false, "VUID-VkSubpassDescription2KHR-flags-parameter");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pSubpasses[%i].flags", ParameterName::IndexVector{ subpassIndex }), "VkSubpassDescriptionFlagBits", AllVkSubpassDescriptionFlagBits, pCreateInfo->pSubpasses[subpassIndex].flags, kOptionalFlags, "VUID-VkSubpassDescription2KHR-flags-parameter");
 
                 skip |= validate_ranged_enum("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pSubpasses[%i].pipelineBindPoint", ParameterName::IndexVector{ subpassIndex }), "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pCreateInfo->pSubpasses[subpassIndex].pipelineBindPoint, "VUID-VkSubpassDescription2KHR-pipelineBindPoint-parameter");
 
@@ -6836,15 +6906,15 @@ bool StatelessValidation::PreCallValidateCreateRenderPass2KHR(
         {
             for (uint32_t dependencyIndex = 0; dependencyIndex < pCreateInfo->dependencyCount; ++dependencyIndex)
             {
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].srcStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcStageMask, true, false, "VUID-VkSubpassDependency2KHR-srcStageMask-requiredbitmask");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].srcStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcStageMask, kRequiredFlags, "VUID-VkSubpassDependency2KHR-srcStageMask-parameter", "VUID-VkSubpassDependency2KHR-srcStageMask-requiredbitmask");
 
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].dstStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstStageMask, true, false, "VUID-VkSubpassDependency2KHR-dstStageMask-requiredbitmask");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].dstStageMask", ParameterName::IndexVector{ dependencyIndex }), "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstStageMask, kRequiredFlags, "VUID-VkSubpassDependency2KHR-dstStageMask-parameter", "VUID-VkSubpassDependency2KHR-dstStageMask-requiredbitmask");
 
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].srcAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcAccessMask, false, false, "VUID-VkSubpassDependency2KHR-srcAccessMask-parameter");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].srcAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].srcAccessMask, kOptionalFlags, "VUID-VkSubpassDependency2KHR-srcAccessMask-parameter");
 
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].dstAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstAccessMask, false, false, "VUID-VkSubpassDependency2KHR-dstAccessMask-parameter");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].dstAccessMask", ParameterName::IndexVector{ dependencyIndex }), "VkAccessFlagBits", AllVkAccessFlagBits, pCreateInfo->pDependencies[dependencyIndex].dstAccessMask, kOptionalFlags, "VUID-VkSubpassDependency2KHR-dstAccessMask-parameter");
 
-                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].dependencyFlags", ParameterName::IndexVector{ dependencyIndex }), "VkDependencyFlagBits", AllVkDependencyFlagBits, pCreateInfo->pDependencies[dependencyIndex].dependencyFlags, false, false, "VUID-VkSubpassDependency2KHR-dependencyFlags-parameter");
+                skip |= validate_flags("vkCreateRenderPass2KHR", ParameterName("pCreateInfo->pDependencies[%i].dependencyFlags", ParameterName::IndexVector{ dependencyIndex }), "VkDependencyFlagBits", AllVkDependencyFlagBits, pCreateInfo->pDependencies[dependencyIndex].dependencyFlags, kOptionalFlags, "VUID-VkSubpassDependency2KHR-dependencyFlags-parameter");
             }
         }
 
@@ -6871,7 +6941,7 @@ bool StatelessValidation::PreCallValidateCreateRenderPass2KHR(
         }
     }
     skip |= validate_required_pointer("vkCreateRenderPass2KHR", "pRenderPass", pRenderPass, "VUID-vkCreateRenderPass2KHR-pRenderPass-parameter");
-    skip |= manual_PreCallValidateCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
+    if (!skip) skip |= manual_PreCallValidateCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
     return skip;
 }
 
@@ -6986,7 +7056,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalFencePropertie
     {
         skip |= validate_struct_pnext("vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceInfo->pNext", NULL, pExternalFenceInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPhysicalDeviceExternalFenceInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pExternalFenceInfo->handleType, true, true, "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter");
+        skip |= validate_flags("vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pExternalFenceInfo->handleType, kRequiredSingleBit, "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter", "VUID-VkPhysicalDeviceExternalFenceInfo-handleType-parameter");
     }
     skip |= validate_struct_type("vkGetPhysicalDeviceExternalFencePropertiesKHR", "pExternalFenceProperties", "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES", pExternalFenceProperties, VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, true, "VUID-vkGetPhysicalDeviceExternalFenceProperties-pExternalFenceProperties-parameter", "VUID-VkExternalFenceProperties-sType-sType");
     if (pExternalFenceProperties != NULL)
@@ -7015,9 +7085,9 @@ bool StatelessValidation::PreCallValidateImportFenceWin32HandleKHR(
 
         skip |= validate_required_handle("vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->fence", pImportFenceWin32HandleInfo->fence);
 
-        skip |= validate_flags("vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->flags", "VkFenceImportFlagBits", AllVkFenceImportFlagBits, pImportFenceWin32HandleInfo->flags, false, false, "VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter");
+        skip |= validate_flags("vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->flags", "VkFenceImportFlagBits", AllVkFenceImportFlagBits, pImportFenceWin32HandleInfo->flags, kOptionalFlags, "VUID-VkImportFenceWin32HandleInfoKHR-flags-parameter");
 
-        skip |= validate_flags("vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pImportFenceWin32HandleInfo->handleType, false, true, "VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkImportFenceWin32HandleKHR", "pImportFenceWin32HandleInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pImportFenceWin32HandleInfo->handleType, kOptionalSingleBit, "VUID-VkImportFenceWin32HandleInfoKHR-handleType-parameter");
     }
     return skip;
 }
@@ -7036,7 +7106,7 @@ bool StatelessValidation::PreCallValidateGetFenceWin32HandleKHR(
 
         skip |= validate_required_handle("vkGetFenceWin32HandleKHR", "pGetWin32HandleInfo->fence", pGetWin32HandleInfo->fence);
 
-        skip |= validate_flags("vkGetFenceWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pGetWin32HandleInfo->handleType, true, true, "VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkGetFenceWin32HandleKHR", "pGetWin32HandleInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pGetWin32HandleInfo->handleType, kRequiredSingleBit, "VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter", "VUID-VkFenceGetWin32HandleInfoKHR-handleType-parameter");
     }
     skip |= validate_required_pointer("vkGetFenceWin32HandleKHR", "pHandle", pHandle, "VUID-vkGetFenceWin32HandleKHR-pHandle-parameter");
     return skip;
@@ -7057,9 +7127,9 @@ bool StatelessValidation::PreCallValidateImportFenceFdKHR(
 
         skip |= validate_required_handle("vkImportFenceFdKHR", "pImportFenceFdInfo->fence", pImportFenceFdInfo->fence);
 
-        skip |= validate_flags("vkImportFenceFdKHR", "pImportFenceFdInfo->flags", "VkFenceImportFlagBits", AllVkFenceImportFlagBits, pImportFenceFdInfo->flags, false, false, "VUID-VkImportFenceFdInfoKHR-flags-parameter");
+        skip |= validate_flags("vkImportFenceFdKHR", "pImportFenceFdInfo->flags", "VkFenceImportFlagBits", AllVkFenceImportFlagBits, pImportFenceFdInfo->flags, kOptionalFlags, "VUID-VkImportFenceFdInfoKHR-flags-parameter");
 
-        skip |= validate_flags("vkImportFenceFdKHR", "pImportFenceFdInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pImportFenceFdInfo->handleType, true, true, "VUID-VkImportFenceFdInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkImportFenceFdKHR", "pImportFenceFdInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pImportFenceFdInfo->handleType, kRequiredSingleBit, "VUID-VkImportFenceFdInfoKHR-handleType-parameter", "VUID-VkImportFenceFdInfoKHR-handleType-parameter");
     }
     return skip;
 }
@@ -7078,7 +7148,7 @@ bool StatelessValidation::PreCallValidateGetFenceFdKHR(
 
         skip |= validate_required_handle("vkGetFenceFdKHR", "pGetFdInfo->fence", pGetFdInfo->fence);
 
-        skip |= validate_flags("vkGetFenceFdKHR", "pGetFdInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pGetFdInfo->handleType, true, true, "VUID-VkFenceGetFdInfoKHR-handleType-parameter");
+        skip |= validate_flags("vkGetFenceFdKHR", "pGetFdInfo->handleType", "VkExternalFenceHandleTypeFlagBits", AllVkExternalFenceHandleTypeFlagBits, pGetFdInfo->handleType, kRequiredSingleBit, "VUID-VkFenceGetFdInfoKHR-handleType-parameter", "VUID-VkFenceGetFdInfoKHR-handleType-parameter");
     }
     skip |= validate_required_pointer("vkGetFenceFdKHR", "pFd", pFd, "VUID-vkGetFenceFdKHR-pFd-parameter");
     return skip;
@@ -7462,7 +7532,7 @@ bool StatelessValidation::PreCallValidateGetDescriptorSetLayoutSupportKHR(
 
         skip |= validate_struct_pnext("vkGetDescriptorSetLayoutSupportKHR", "pCreateInfo->pNext", "VkDescriptorSetLayoutBindingFlagsCreateInfoEXT", pCreateInfo->pNext, ARRAY_SIZE(allowed_structs_VkDescriptorSetLayoutCreateInfo), allowed_structs_VkDescriptorSetLayoutCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkDescriptorSetLayoutCreateInfo-pNext-pNext");
 
-        skip |= validate_flags("vkGetDescriptorSetLayoutSupportKHR", "pCreateInfo->flags", "VkDescriptorSetLayoutCreateFlagBits", AllVkDescriptorSetLayoutCreateFlagBits, pCreateInfo->flags, false, false, "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter");
+        skip |= validate_flags("vkGetDescriptorSetLayoutSupportKHR", "pCreateInfo->flags", "VkDescriptorSetLayoutCreateFlagBits", AllVkDescriptorSetLayoutCreateFlagBits, pCreateInfo->flags, kOptionalFlags, "VUID-VkDescriptorSetLayoutCreateInfo-flags-parameter");
 
         skip |= validate_array("vkGetDescriptorSetLayoutSupportKHR", "pCreateInfo->bindingCount", "pCreateInfo->pBindings", pCreateInfo->bindingCount, &pCreateInfo->pBindings, false, true, kVUIDUndefined, "VUID-VkDescriptorSetLayoutCreateInfo-pBindings-parameter");
 
@@ -7534,6 +7604,76 @@ bool StatelessValidation::PreCallValidateCmdDrawIndexedIndirectCountKHR(
 
 
 
+bool StatelessValidation::PreCallValidateGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties) {
+    bool skip = false;
+    if (!device_extensions.vk_khr_pipeline_executable_properties) skip |= OutputExtensionError("vkGetPipelineExecutablePropertiesKHR", VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+    skip |= validate_struct_type("vkGetPipelineExecutablePropertiesKHR", "pPipelineInfo", "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR", pPipelineInfo, VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, true, "VUID-vkGetPipelineExecutablePropertiesKHR-pPipelineInfo-parameter", "VUID-VkPipelineInfoKHR-sType-sType");
+    if (pPipelineInfo != NULL)
+    {
+        skip |= validate_struct_pnext("vkGetPipelineExecutablePropertiesKHR", "pPipelineInfo->pNext", NULL, pPipelineInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPipelineInfoKHR-pNext-pNext");
+
+        skip |= validate_required_handle("vkGetPipelineExecutablePropertiesKHR", "pPipelineInfo->pipeline", pPipelineInfo->pipeline);
+    }
+    skip |= validate_struct_type_array("vkGetPipelineExecutablePropertiesKHR", "pExecutableCount", "pProperties", "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR", pExecutableCount, pProperties, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR, true, false, false, "VUID-VkPipelineExecutablePropertiesKHR-sType-sType", "VUID-vkGetPipelineExecutablePropertiesKHR-pProperties-parameter", kVUIDUndefined);
+    if (pProperties != NULL)
+    {
+        for (uint32_t pExecutableIndex = 0; pExecutableIndex < *pExecutableCount; ++pExecutableIndex)
+        {
+            // No xml-driven validation
+        }
+    }
+    return skip;
+}
+
+bool StatelessValidation::PreCallValidateGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics) {
+    bool skip = false;
+    if (!device_extensions.vk_khr_pipeline_executable_properties) skip |= OutputExtensionError("vkGetPipelineExecutableStatisticsKHR", VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+    skip |= validate_struct_type("vkGetPipelineExecutableStatisticsKHR", "pExecutableInfo", "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR", pExecutableInfo, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, true, "VUID-vkGetPipelineExecutableStatisticsKHR-pExecutableInfo-parameter", "VUID-VkPipelineExecutableInfoKHR-sType-sType");
+    if (pExecutableInfo != NULL)
+    {
+        skip |= validate_struct_pnext("vkGetPipelineExecutableStatisticsKHR", "pExecutableInfo->pNext", NULL, pExecutableInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPipelineExecutableInfoKHR-pNext-pNext");
+
+        skip |= validate_required_handle("vkGetPipelineExecutableStatisticsKHR", "pExecutableInfo->pipeline", pExecutableInfo->pipeline);
+    }
+    skip |= validate_struct_type_array("vkGetPipelineExecutableStatisticsKHR", "pStatisticCount", "pStatistics", "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR", pStatisticCount, pStatistics, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR, true, false, false, "VUID-VkPipelineExecutableStatisticKHR-sType-sType", "VUID-vkGetPipelineExecutableStatisticsKHR-pStatistics-parameter", kVUIDUndefined);
+    if (pStatistics != NULL)
+    {
+        for (uint32_t pStatisticIndex = 0; pStatisticIndex < *pStatisticCount; ++pStatisticIndex)
+        {
+            // No xml-driven validation
+        }
+    }
+    return skip;
+}
+
+bool StatelessValidation::PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
+    bool skip = false;
+    if (!device_extensions.vk_khr_pipeline_executable_properties) skip |= OutputExtensionError("vkGetPipelineExecutableInternalRepresentationsKHR", VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+    skip |= validate_struct_type("vkGetPipelineExecutableInternalRepresentationsKHR", "pExecutableInfo", "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR", pExecutableInfo, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR, true, "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pExecutableInfo-parameter", "VUID-VkPipelineExecutableInfoKHR-sType-sType");
+    if (pExecutableInfo != NULL)
+    {
+        skip |= validate_struct_pnext("vkGetPipelineExecutableInternalRepresentationsKHR", "pExecutableInfo->pNext", NULL, pExecutableInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPipelineExecutableInfoKHR-pNext-pNext");
+
+        skip |= validate_required_handle("vkGetPipelineExecutableInternalRepresentationsKHR", "pExecutableInfo->pipeline", pExecutableInfo->pipeline);
+    }
+    skip |= validate_struct_type_array("vkGetPipelineExecutableInternalRepresentationsKHR", "pInternalRepresentationCount", "pInternalRepresentations", "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR", pInternalRepresentationCount, pInternalRepresentations, VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR, true, false, false, "VUID-VkPipelineExecutableInternalRepresentationKHR-sType-sType", "VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentations-parameter", kVUIDUndefined);
+    return skip;
+}
+
+
+
 bool StatelessValidation::PreCallValidateCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -7546,7 +7686,7 @@ bool StatelessValidation::PreCallValidateCreateDebugReportCallbackEXT(
     {
         skip |= validate_struct_pnext("vkCreateDebugReportCallbackEXT", "pCreateInfo->pNext", NULL, pCreateInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined);
 
-        skip |= validate_flags("vkCreateDebugReportCallbackEXT", "pCreateInfo->flags", "VkDebugReportFlagBitsEXT", AllVkDebugReportFlagBitsEXT, pCreateInfo->flags, false, false, "VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter");
+        skip |= validate_flags("vkCreateDebugReportCallbackEXT", "pCreateInfo->flags", "VkDebugReportFlagBitsEXT", AllVkDebugReportFlagBitsEXT, pCreateInfo->flags, kOptionalFlags, "VUID-VkDebugReportCallbackCreateInfoEXT-flags-parameter");
 
         skip |= validate_required_pointer("vkCreateDebugReportCallbackEXT", "pCreateInfo->pfnCallback", reinterpret_cast<const void*>(pCreateInfo->pfnCallback), "VUID-VkDebugReportCallbackCreateInfoEXT-pfnCallback-parameter");
     }
@@ -7615,7 +7755,7 @@ bool StatelessValidation::PreCallValidateDebugReportMessageEXT(
     const char*                                 pMessage) {
     bool skip = false;
     if (!instance_extensions.vk_ext_debug_report) skip |= OutputExtensionError("vkDebugReportMessageEXT", VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
-    skip |= validate_flags("vkDebugReportMessageEXT", "flags", "VkDebugReportFlagBitsEXT", AllVkDebugReportFlagBitsEXT, flags, true, false, "VUID-vkDebugReportMessageEXT-flags-requiredbitmask");
+    skip |= validate_flags("vkDebugReportMessageEXT", "flags", "VkDebugReportFlagBitsEXT", AllVkDebugReportFlagBitsEXT, flags, kRequiredFlags, "VUID-vkDebugReportMessageEXT-flags-parameter", "VUID-vkDebugReportMessageEXT-flags-requiredbitmask");
     skip |= validate_ranged_enum("vkDebugReportMessageEXT", "objectType", "VkDebugReportObjectTypeEXT", AllVkDebugReportObjectTypeEXTEnums, objectType, "VUID-vkDebugReportMessageEXT-objectType-parameter");
     skip |= validate_required_pointer("vkDebugReportMessageEXT", "pLayerPrefix", pLayerPrefix, "VUID-vkDebugReportMessageEXT-pLayerPrefix-parameter");
     skip |= validate_required_pointer("vkDebugReportMessageEXT", "pMessage", pMessage, "VUID-vkDebugReportMessageEXT-pMessage-parameter");
@@ -7771,7 +7911,7 @@ bool StatelessValidation::PreCallValidateCmdBeginQueryIndexedEXT(
     if (!device_extensions.vk_khr_get_physical_device_properties_2) skip |= OutputExtensionError("vkCmdBeginQueryIndexedEXT", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
     if (!device_extensions.vk_ext_transform_feedback) skip |= OutputExtensionError("vkCmdBeginQueryIndexedEXT", VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME);
     skip |= validate_required_handle("vkCmdBeginQueryIndexedEXT", "queryPool", queryPool);
-    skip |= validate_flags("vkCmdBeginQueryIndexedEXT", "flags", "VkQueryControlFlagBits", AllVkQueryControlFlagBits, flags, false, false, "VUID-vkCmdBeginQueryIndexedEXT-flags-parameter");
+    skip |= validate_flags("vkCmdBeginQueryIndexedEXT", "flags", "VkQueryControlFlagBits", AllVkQueryControlFlagBits, flags, kOptionalFlags, "VUID-vkCmdBeginQueryIndexedEXT-flags-parameter");
     return skip;
 }
 
@@ -7873,7 +8013,7 @@ bool StatelessValidation::PreCallValidateGetShaderInfoAMD(
     bool skip = false;
     if (!device_extensions.vk_amd_shader_info) skip |= OutputExtensionError("vkGetShaderInfoAMD", VK_AMD_SHADER_INFO_EXTENSION_NAME);
     skip |= validate_required_handle("vkGetShaderInfoAMD", "pipeline", pipeline);
-    skip |= validate_flags("vkGetShaderInfoAMD", "shaderStage", "VkShaderStageFlagBits", AllVkShaderStageFlagBits, shaderStage, true, true, "VUID-vkGetShaderInfoAMD-shaderStage-parameter");
+    skip |= validate_flags("vkGetShaderInfoAMD", "shaderStage", "VkShaderStageFlagBits", AllVkShaderStageFlagBits, shaderStage, kRequiredSingleBit, "VUID-vkGetShaderInfoAMD-shaderStage-parameter", "VUID-vkGetShaderInfoAMD-shaderStage-parameter");
     skip |= validate_ranged_enum("vkGetShaderInfoAMD", "infoType", "VkShaderInfoTypeAMD", AllVkShaderInfoTypeAMDEnums, infoType, "VUID-vkGetShaderInfoAMD-infoType-parameter");
     skip |= validate_array("vkGetShaderInfoAMD", "pInfoSize", "pInfo", pInfoSize, &pInfo, true, false, false, kVUIDUndefined, "VUID-vkGetShaderInfoAMD-pInfo-parameter");
     return skip;
@@ -7944,9 +8084,9 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceExternalImageFormatPro
     skip |= validate_ranged_enum("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "format", "VkFormat", AllVkFormatEnums, format, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-format-parameter");
     skip |= validate_ranged_enum("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "type", "VkImageType", AllVkImageTypeEnums, type, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-type-parameter");
     skip |= validate_ranged_enum("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "tiling", "VkImageTiling", AllVkImageTilingEnums, tiling, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-tiling-parameter");
-    skip |= validate_flags("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, true, false, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask");
-    skip |= validate_flags("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, false, false, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter");
-    skip |= validate_flags("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "externalHandleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, externalHandleType, false, false, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter");
+    skip |= validate_flags("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "usage", "VkImageUsageFlagBits", AllVkImageUsageFlagBits, usage, kRequiredFlags, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-parameter", "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-usage-requiredbitmask");
+    skip |= validate_flags("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "flags", "VkImageCreateFlagBits", AllVkImageCreateFlagBits, flags, kOptionalFlags, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-flags-parameter");
+    skip |= validate_flags("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "externalHandleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, externalHandleType, kOptionalFlags, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-externalHandleType-parameter");
     skip |= validate_required_pointer("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", "pExternalImageFormatProperties", pExternalImageFormatProperties, "VUID-vkGetPhysicalDeviceExternalImageFormatPropertiesNV-pExternalImageFormatProperties-parameter");
     if (pExternalImageFormatProperties != NULL)
     {
@@ -7970,7 +8110,7 @@ bool StatelessValidation::PreCallValidateGetMemoryWin32HandleNV(
     if (!device_extensions.vk_nv_external_memory) skip |= OutputExtensionError("vkGetMemoryWin32HandleNV", VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME);
     if (!device_extensions.vk_nv_external_memory_win32) skip |= OutputExtensionError("vkGetMemoryWin32HandleNV", VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME);
     skip |= validate_required_handle("vkGetMemoryWin32HandleNV", "memory", memory);
-    skip |= validate_flags("vkGetMemoryWin32HandleNV", "handleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, handleType, true, false, "VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask");
+    skip |= validate_flags("vkGetMemoryWin32HandleNV", "handleType", "VkExternalMemoryHandleTypeFlagBitsNV", AllVkExternalMemoryHandleTypeFlagBitsNV, handleType, kRequiredFlags, "VUID-vkGetMemoryWin32HandleNV-handleType-parameter", "VUID-vkGetMemoryWin32HandleNV-handleType-requiredbitmask");
     skip |= validate_required_pointer("vkGetMemoryWin32HandleNV", "pHandle", pHandle, "VUID-vkGetMemoryWin32HandleNV-pHandle-parameter");
     return skip;
 }
@@ -8032,6 +8172,8 @@ bool StatelessValidation::PreCallValidateCreateViSurfaceNN(
 
 
 
+
+
 bool StatelessValidation::PreCallValidateCmdBeginConditionalRenderingEXT(
     VkCommandBuffer                             commandBuffer,
     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin) {
@@ -8044,7 +8186,7 @@ bool StatelessValidation::PreCallValidateCmdBeginConditionalRenderingEXT(
 
         skip |= validate_required_handle("vkCmdBeginConditionalRenderingEXT", "pConditionalRenderingBegin->buffer", pConditionalRenderingBegin->buffer);
 
-        skip |= validate_flags("vkCmdBeginConditionalRenderingEXT", "pConditionalRenderingBegin->flags", "VkConditionalRenderingFlagBitsEXT", AllVkConditionalRenderingFlagBitsEXT, pConditionalRenderingBegin->flags, false, false, "VUID-VkConditionalRenderingBeginInfoEXT-flags-parameter");
+        skip |= validate_flags("vkCmdBeginConditionalRenderingEXT", "pConditionalRenderingBegin->flags", "VkConditionalRenderingFlagBitsEXT", AllVkConditionalRenderingFlagBitsEXT, pConditionalRenderingBegin->flags, kOptionalFlags, "VUID-VkConditionalRenderingBeginInfoEXT-flags-parameter");
     }
     return skip;
 }
@@ -8119,7 +8261,7 @@ bool StatelessValidation::PreCallValidateCreateIndirectCommandsLayoutNVX(
 
         skip |= validate_ranged_enum("vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->pipelineBindPoint", "VkPipelineBindPoint", AllVkPipelineBindPointEnums, pCreateInfo->pipelineBindPoint, "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pipelineBindPoint-parameter");
 
-        skip |= validate_flags("vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->flags", "VkIndirectCommandsLayoutUsageFlagBitsNVX", AllVkIndirectCommandsLayoutUsageFlagBitsNVX, pCreateInfo->flags, true, false, "VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask");
+        skip |= validate_flags("vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->flags", "VkIndirectCommandsLayoutUsageFlagBitsNVX", AllVkIndirectCommandsLayoutUsageFlagBitsNVX, pCreateInfo->flags, kRequiredFlags, "VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-parameter", "VUID-VkIndirectCommandsLayoutCreateInfoNVX-flags-requiredbitmask");
 
         skip |= validate_array("vkCreateIndirectCommandsLayoutNVX", "pCreateInfo->tokenCount", "pCreateInfo->pTokens", pCreateInfo->tokenCount, &pCreateInfo->pTokens, true, true, "VUID-VkIndirectCommandsLayoutCreateInfoNVX-tokenCount-arraylength", "VUID-VkIndirectCommandsLayoutCreateInfoNVX-pTokens-parameter");
 
@@ -8273,7 +8415,7 @@ bool StatelessValidation::PreCallValidateRegisterObjectsNVX(
         {
             skip |= validate_ranged_enum("vkRegisterObjectsNVX", ParameterName("ppObjectTableEntries[%i]->type", ParameterName::IndexVector{ objectIndex }), "VkObjectEntryTypeNVX", AllVkObjectEntryTypeNVXEnums, ppObjectTableEntries[objectIndex]->type, "VUID-VkObjectTableEntryNVX-type-parameter");
 
-            skip |= validate_flags("vkRegisterObjectsNVX", ParameterName("ppObjectTableEntries[%i]->flags", ParameterName::IndexVector{ objectIndex }), "VkObjectEntryUsageFlagBitsNVX", AllVkObjectEntryUsageFlagBitsNVX, ppObjectTableEntries[objectIndex]->flags, true, false, "VUID-VkObjectTableEntryNVX-flags-requiredbitmask");
+            skip |= validate_flags("vkRegisterObjectsNVX", ParameterName("ppObjectTableEntries[%i]->flags", ParameterName::IndexVector{ objectIndex }), "VkObjectEntryUsageFlagBitsNVX", AllVkObjectEntryUsageFlagBitsNVX, ppObjectTableEntries[objectIndex]->flags, kRequiredFlags, "VUID-VkObjectTableEntryNVX-flags-parameter", "VUID-VkObjectTableEntryNVX-flags-requiredbitmask");
         }
     }
     skip |= validate_array("vkRegisterObjectsNVX", "objectCount", "pObjectIndices", objectCount, &pObjectIndices, true, true, "VUID-vkRegisterObjectsNVX-objectCount-arraylength", "VUID-vkRegisterObjectsNVX-pObjectIndices-parameter");
@@ -8496,7 +8638,7 @@ bool StatelessValidation::PreCallValidateGetSwapchainCounterEXT(
     if (!device_extensions.vk_ext_display_surface_counter) skip |= OutputExtensionError("vkGetSwapchainCounterEXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME);
     if (!device_extensions.vk_ext_display_control) skip |= OutputExtensionError("vkGetSwapchainCounterEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME);
     skip |= validate_required_handle("vkGetSwapchainCounterEXT", "swapchain", swapchain);
-    skip |= validate_flags("vkGetSwapchainCounterEXT", "counter", "VkSurfaceCounterFlagBitsEXT", AllVkSurfaceCounterFlagBitsEXT, counter, true, true, "VUID-vkGetSwapchainCounterEXT-counter-parameter");
+    skip |= validate_flags("vkGetSwapchainCounterEXT", "counter", "VkSurfaceCounterFlagBitsEXT", AllVkSurfaceCounterFlagBitsEXT, counter, kRequiredSingleBit, "VUID-vkGetSwapchainCounterEXT-counter-parameter", "VUID-vkGetSwapchainCounterEXT-counter-parameter");
     skip |= validate_required_pointer("vkGetSwapchainCounterEXT", "pCounterValue", pCounterValue, "VUID-vkGetSwapchainCounterEXT-pCounterValue-parameter");
     return skip;
 }
@@ -8814,9 +8956,9 @@ bool StatelessValidation::PreCallValidateCreateDebugUtilsMessengerEXT(
 
         skip |= validate_reserved_flags("vkCreateDebugUtilsMessengerEXT", "pCreateInfo->flags", pCreateInfo->flags, "VUID-VkDebugUtilsMessengerCreateInfoEXT-flags-zerobitmask");
 
-        skip |= validate_flags("vkCreateDebugUtilsMessengerEXT", "pCreateInfo->messageSeverity", "VkDebugUtilsMessageSeverityFlagBitsEXT", AllVkDebugUtilsMessageSeverityFlagBitsEXT, pCreateInfo->messageSeverity, true, false, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask");
+        skip |= validate_flags("vkCreateDebugUtilsMessengerEXT", "pCreateInfo->messageSeverity", "VkDebugUtilsMessageSeverityFlagBitsEXT", AllVkDebugUtilsMessageSeverityFlagBitsEXT, pCreateInfo->messageSeverity, kRequiredFlags, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-parameter", "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageSeverity-requiredbitmask");
 
-        skip |= validate_flags("vkCreateDebugUtilsMessengerEXT", "pCreateInfo->messageType", "VkDebugUtilsMessageTypeFlagBitsEXT", AllVkDebugUtilsMessageTypeFlagBitsEXT, pCreateInfo->messageType, true, false, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask");
+        skip |= validate_flags("vkCreateDebugUtilsMessengerEXT", "pCreateInfo->messageType", "VkDebugUtilsMessageTypeFlagBitsEXT", AllVkDebugUtilsMessageTypeFlagBitsEXT, pCreateInfo->messageType, kRequiredFlags, "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-parameter", "VUID-VkDebugUtilsMessengerCreateInfoEXT-messageType-requiredbitmask");
 
         skip |= validate_required_pointer("vkCreateDebugUtilsMessengerEXT", "pCreateInfo->pfnUserCallback", reinterpret_cast<const void*>(pCreateInfo->pfnUserCallback), "VUID-VkDebugUtilsMessengerCreateInfoEXT-pfnUserCallback-parameter");
     }
@@ -8881,8 +9023,8 @@ bool StatelessValidation::PreCallValidateSubmitDebugUtilsMessageEXT(
     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
     bool skip = false;
     if (!instance_extensions.vk_ext_debug_utils) skip |= OutputExtensionError("vkSubmitDebugUtilsMessageEXT", VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-    skip |= validate_flags("vkSubmitDebugUtilsMessageEXT", "messageSeverity", "VkDebugUtilsMessageSeverityFlagBitsEXT", AllVkDebugUtilsMessageSeverityFlagBitsEXT, messageSeverity, true, true, "VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter");
-    skip |= validate_flags("vkSubmitDebugUtilsMessageEXT", "messageTypes", "VkDebugUtilsMessageTypeFlagBitsEXT", AllVkDebugUtilsMessageTypeFlagBitsEXT, messageTypes, true, false, "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask");
+    skip |= validate_flags("vkSubmitDebugUtilsMessageEXT", "messageSeverity", "VkDebugUtilsMessageSeverityFlagBitsEXT", AllVkDebugUtilsMessageSeverityFlagBitsEXT, messageSeverity, kRequiredSingleBit, "VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter", "VUID-vkSubmitDebugUtilsMessageEXT-messageSeverity-parameter");
+    skip |= validate_flags("vkSubmitDebugUtilsMessageEXT", "messageTypes", "VkDebugUtilsMessageTypeFlagBitsEXT", AllVkDebugUtilsMessageTypeFlagBitsEXT, messageTypes, kRequiredFlags, "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-parameter", "VUID-vkSubmitDebugUtilsMessageEXT-messageTypes-requiredbitmask");
     skip |= validate_struct_type("vkSubmitDebugUtilsMessageEXT", "pCallbackData", "VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT", pCallbackData, VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT, true, "VUID-vkSubmitDebugUtilsMessageEXT-pCallbackData-parameter", "VUID-VkDebugUtilsMessengerCallbackDataEXT-sType-sType");
     if (pCallbackData != NULL)
     {
@@ -8998,7 +9140,7 @@ bool StatelessValidation::PreCallValidateCmdSetSampleLocationsEXT(
     {
         skip |= validate_struct_pnext("vkCmdSetSampleLocationsEXT", "pSampleLocationsInfo->pNext", NULL, pSampleLocationsInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion, kVUIDUndefined);
 
-        skip |= validate_flags("vkCmdSetSampleLocationsEXT", "pSampleLocationsInfo->sampleLocationsPerPixel", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pSampleLocationsInfo->sampleLocationsPerPixel, false, true, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
+        skip |= validate_flags("vkCmdSetSampleLocationsEXT", "pSampleLocationsInfo->sampleLocationsPerPixel", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pSampleLocationsInfo->sampleLocationsPerPixel, kOptionalSingleBit, "VUID-VkSampleLocationsInfoEXT-sampleLocationsPerPixel-parameter");
 
         // No xml-driven validation
 
@@ -9020,7 +9162,7 @@ bool StatelessValidation::PreCallValidateGetPhysicalDeviceMultisamplePropertiesE
     VkSampleCountFlagBits                       samples,
     VkMultisamplePropertiesEXT*                 pMultisampleProperties) {
     bool skip = false;
-    skip |= validate_flags("vkGetPhysicalDeviceMultisamplePropertiesEXT", "samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, samples, true, true, "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter");
+    skip |= validate_flags("vkGetPhysicalDeviceMultisamplePropertiesEXT", "samples", "VkSampleCountFlagBits", AllVkSampleCountFlagBits, samples, kRequiredSingleBit, "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter", "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-samples-parameter");
     skip |= validate_struct_type("vkGetPhysicalDeviceMultisamplePropertiesEXT", "pMultisampleProperties", "VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT", pMultisampleProperties, VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT, true, "VUID-vkGetPhysicalDeviceMultisamplePropertiesEXT-pMultisampleProperties-parameter", "VUID-VkMultisamplePropertiesEXT-sType-sType");
     if (pMultisampleProperties != NULL)
     {
@@ -9190,7 +9332,7 @@ bool StatelessValidation::PreCallValidateCmdSetViewportShadingRatePaletteNV(
             skip |= validate_ranged_enum_array("vkCmdSetViewportShadingRatePaletteNV", ParameterName("pShadingRatePalettes[%i].shadingRatePaletteEntryCount", ParameterName::IndexVector{ viewportIndex }), ParameterName("pShadingRatePalettes[%i].pShadingRatePaletteEntries", ParameterName::IndexVector{ viewportIndex }), "VkShadingRatePaletteEntryNV", AllVkShadingRatePaletteEntryNVEnums, pShadingRatePalettes[viewportIndex].shadingRatePaletteEntryCount, pShadingRatePalettes[viewportIndex].pShadingRatePaletteEntries, true, true);
         }
     }
-    skip |= manual_PreCallValidateCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
+    if (!skip) skip |= manual_PreCallValidateCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes);
     return skip;
 }
 
@@ -9221,7 +9363,7 @@ bool StatelessValidation::PreCallValidateCmdSetCoarseSampleOrderNV(
             }
         }
     }
-    skip |= manual_PreCallValidateCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
+    if (!skip) skip |= manual_PreCallValidateCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders);
     return skip;
 }
 
@@ -9247,7 +9389,7 @@ bool StatelessValidation::PreCallValidateCreateAccelerationStructureNV(
 
         skip |= validate_ranged_enum("vkCreateAccelerationStructureNV", "pCreateInfo->info.type", "VkAccelerationStructureTypeNV", AllVkAccelerationStructureTypeNVEnums, pCreateInfo->info.type, "VUID-VkAccelerationStructureInfoNV-type-parameter");
 
-        skip |= validate_flags("vkCreateAccelerationStructureNV", "pCreateInfo->info.flags", "VkBuildAccelerationStructureFlagBitsNV", AllVkBuildAccelerationStructureFlagBitsNV, pCreateInfo->info.flags, false, false, "VUID-VkAccelerationStructureInfoNV-flags-parameter");
+        skip |= validate_flags("vkCreateAccelerationStructureNV", "pCreateInfo->info.flags", "VkBuildAccelerationStructureFlagBitsNV", AllVkBuildAccelerationStructureFlagBitsNV, pCreateInfo->info.flags, kOptionalFlags, "VUID-VkAccelerationStructureInfoNV-flags-parameter");
 
         skip |= validate_struct_type_array("vkCreateAccelerationStructureNV", "pCreateInfo->info.geometryCount", "pCreateInfo->info.pGeometries", "VK_STRUCTURE_TYPE_GEOMETRY_NV", pCreateInfo->info.geometryCount, pCreateInfo->info.pGeometries, VK_STRUCTURE_TYPE_GEOMETRY_NV, false, true, "VUID-VkGeometryNV-sType-sType", "VUID-VkAccelerationStructureInfoNV-pGeometries-parameter", kVUIDUndefined);
 
@@ -9271,7 +9413,7 @@ bool StatelessValidation::PreCallValidateCreateAccelerationStructureNV(
 
                 skip |= validate_struct_pnext("vkCreateAccelerationStructureNV", ParameterName("pCreateInfo->info.pGeometries[%i].geometry.aabbs.pNext", ParameterName::IndexVector{ geometryIndex }), NULL, pCreateInfo->info.pGeometries[geometryIndex].geometry.aabbs.pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkGeometryAABBNV-pNext-pNext");
 
-                skip |= validate_flags("vkCreateAccelerationStructureNV", ParameterName("pCreateInfo->info.pGeometries[%i].flags", ParameterName::IndexVector{ geometryIndex }), "VkGeometryFlagBitsNV", AllVkGeometryFlagBitsNV, pCreateInfo->info.pGeometries[geometryIndex].flags, false, false, "VUID-VkGeometryNV-flags-parameter");
+                skip |= validate_flags("vkCreateAccelerationStructureNV", ParameterName("pCreateInfo->info.pGeometries[%i].flags", ParameterName::IndexVector{ geometryIndex }), "VkGeometryFlagBitsNV", AllVkGeometryFlagBitsNV, pCreateInfo->info.pGeometries[geometryIndex].flags, kOptionalFlags, "VUID-VkGeometryNV-flags-parameter");
             }
         }
     }
@@ -9296,7 +9438,7 @@ bool StatelessValidation::PreCallValidateCreateAccelerationStructureNV(
         }
     }
     skip |= validate_required_pointer("vkCreateAccelerationStructureNV", "pAccelerationStructure", pAccelerationStructure, "VUID-vkCreateAccelerationStructureNV-pAccelerationStructure-parameter");
-    skip |= manual_PreCallValidateCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
+    if (!skip) skip |= manual_PreCallValidateCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure);
     return skip;
 }
 
@@ -9399,7 +9541,7 @@ bool StatelessValidation::PreCallValidateCmdBuildAccelerationStructureNV(
 
         skip |= validate_ranged_enum("vkCmdBuildAccelerationStructureNV", "pInfo->type", "VkAccelerationStructureTypeNV", AllVkAccelerationStructureTypeNVEnums, pInfo->type, "VUID-VkAccelerationStructureInfoNV-type-parameter");
 
-        skip |= validate_flags("vkCmdBuildAccelerationStructureNV", "pInfo->flags", "VkBuildAccelerationStructureFlagBitsNV", AllVkBuildAccelerationStructureFlagBitsNV, pInfo->flags, false, false, "VUID-VkAccelerationStructureInfoNV-flags-parameter");
+        skip |= validate_flags("vkCmdBuildAccelerationStructureNV", "pInfo->flags", "VkBuildAccelerationStructureFlagBitsNV", AllVkBuildAccelerationStructureFlagBitsNV, pInfo->flags, kOptionalFlags, "VUID-VkAccelerationStructureInfoNV-flags-parameter");
 
         skip |= validate_struct_type_array("vkCmdBuildAccelerationStructureNV", "pInfo->geometryCount", "pInfo->pGeometries", "VK_STRUCTURE_TYPE_GEOMETRY_NV", pInfo->geometryCount, pInfo->pGeometries, VK_STRUCTURE_TYPE_GEOMETRY_NV, false, true, "VUID-VkGeometryNV-sType-sType", "VUID-VkAccelerationStructureInfoNV-pGeometries-parameter", kVUIDUndefined);
 
@@ -9423,14 +9565,14 @@ bool StatelessValidation::PreCallValidateCmdBuildAccelerationStructureNV(
 
                 skip |= validate_struct_pnext("vkCmdBuildAccelerationStructureNV", ParameterName("pInfo->pGeometries[%i].geometry.aabbs.pNext", ParameterName::IndexVector{ geometryIndex }), NULL, pInfo->pGeometries[geometryIndex].geometry.aabbs.pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkGeometryAABBNV-pNext-pNext");
 
-                skip |= validate_flags("vkCmdBuildAccelerationStructureNV", ParameterName("pInfo->pGeometries[%i].flags", ParameterName::IndexVector{ geometryIndex }), "VkGeometryFlagBitsNV", AllVkGeometryFlagBitsNV, pInfo->pGeometries[geometryIndex].flags, false, false, "VUID-VkGeometryNV-flags-parameter");
+                skip |= validate_flags("vkCmdBuildAccelerationStructureNV", ParameterName("pInfo->pGeometries[%i].flags", ParameterName::IndexVector{ geometryIndex }), "VkGeometryFlagBitsNV", AllVkGeometryFlagBitsNV, pInfo->pGeometries[geometryIndex].flags, kOptionalFlags, "VUID-VkGeometryNV-flags-parameter");
             }
         }
     }
     skip |= validate_bool32("vkCmdBuildAccelerationStructureNV", "update", update);
     skip |= validate_required_handle("vkCmdBuildAccelerationStructureNV", "dst", dst);
     skip |= validate_required_handle("vkCmdBuildAccelerationStructureNV", "scratch", scratch);
-    skip |= manual_PreCallValidateCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
+    if (!skip) skip |= manual_PreCallValidateCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset);
     return skip;
 }
 
@@ -9493,7 +9635,7 @@ bool StatelessValidation::PreCallValidateCreateRayTracingPipelinesNV(
 
             skip |= validate_struct_pnext("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pNext", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreationFeedbackCreateInfoEXT", pCreateInfos[createInfoIndex].pNext, ARRAY_SIZE(allowed_structs_VkRayTracingPipelineCreateInfoNV), allowed_structs_VkRayTracingPipelineCreateInfoNV, GeneratedVulkanHeaderVersion, "VUID-VkRayTracingPipelineCreateInfoNV-pNext-pNext");
 
-            skip |= validate_flags("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, false, false, "VUID-VkRayTracingPipelineCreateInfoNV-flags-parameter");
+            skip |= validate_flags("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].flags", ParameterName::IndexVector{ createInfoIndex }), "VkPipelineCreateFlagBits", AllVkPipelineCreateFlagBits, pCreateInfos[createInfoIndex].flags, kOptionalFlags, "VUID-VkRayTracingPipelineCreateInfoNV-flags-parameter");
 
             skip |= validate_struct_type_array("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].stageCount", ParameterName::IndexVector{ createInfoIndex }), ParameterName("pCreateInfos[%i].pStages", ParameterName::IndexVector{ createInfoIndex }), "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO", pCreateInfos[createInfoIndex].stageCount, pCreateInfos[createInfoIndex].pStages, VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, true, true, "VUID-VkPipelineShaderStageCreateInfo-sType-sType", "VUID-VkRayTracingPipelineCreateInfoNV-pStages-parameter", "VUID-VkRayTracingPipelineCreateInfoNV-stageCount-arraylength");
 
@@ -9501,11 +9643,13 @@ bool StatelessValidation::PreCallValidateCreateRayTracingPipelinesNV(
             {
                 for (uint32_t stageIndex = 0; stageIndex < pCreateInfos[createInfoIndex].stageCount; ++stageIndex)
                 {
-                    skip |= validate_struct_pnext("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pStages[%i].pNext", ParameterName::IndexVector{ createInfoIndex, stageIndex }), NULL, pCreateInfos[createInfoIndex].pStages[stageIndex].pNext, 0, NULL, GeneratedVulkanHeaderVersion, "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext");
+                    const VkStructureType allowed_structs_VkPipelineShaderStageCreateInfo[] = { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT };
+
+                    skip |= validate_struct_pnext("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pStages[%i].pNext", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT", pCreateInfos[createInfoIndex].pStages[stageIndex].pNext, ARRAY_SIZE(allowed_structs_VkPipelineShaderStageCreateInfo), allowed_structs_VkPipelineShaderStageCreateInfo, GeneratedVulkanHeaderVersion, "VUID-VkPipelineShaderStageCreateInfo-pNext-pNext");
 
-                    skip |= validate_reserved_flags("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pStages[%i].flags", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].flags, "VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask");
+                    skip |= validate_flags("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pStages[%i].flags", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkPipelineShaderStageCreateFlagBits", AllVkPipelineShaderStageCreateFlagBits, pCreateInfos[createInfoIndex].pStages[stageIndex].flags, kOptionalFlags, "VUID-VkPipelineShaderStageCreateInfo-flags-parameter");
 
-                    skip |= validate_flags("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pStages[%i].stage", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].pStages[stageIndex].stage, true, true, "VUID-VkPipelineShaderStageCreateInfo-stage-parameter");
+                    skip |= validate_flags("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pStages[%i].stage", ParameterName::IndexVector{ createInfoIndex, stageIndex }), "VkShaderStageFlagBits", AllVkShaderStageFlagBits, pCreateInfos[createInfoIndex].pStages[stageIndex].stage, kRequiredSingleBit, "VUID-VkPipelineShaderStageCreateInfo-stage-parameter", "VUID-VkPipelineShaderStageCreateInfo-stage-parameter");
 
                     skip |= validate_required_handle("vkCreateRayTracingPipelinesNV", ParameterName("pCreateInfos[%i].pStages[%i].module", ParameterName::IndexVector{ createInfoIndex, stageIndex }), pCreateInfos[createInfoIndex].pStages[stageIndex].module);
 
@@ -9564,7 +9708,7 @@ bool StatelessValidation::PreCallValidateCreateRayTracingPipelinesNV(
         }
     }
     skip |= validate_array("vkCreateRayTracingPipelinesNV", "createInfoCount", "pPipelines", createInfoCount, &pPipelines, true, true, "VUID-vkCreateRayTracingPipelinesNV-createInfoCount-arraylength", "VUID-vkCreateRayTracingPipelinesNV-pPipelines-parameter");
-    skip |= manual_PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+    if (!skip) skip |= manual_PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     return skip;
 }
 
@@ -9595,7 +9739,7 @@ bool StatelessValidation::PreCallValidateGetAccelerationStructureHandleNV(
     if (!device_extensions.vk_nv_ray_tracing) skip |= OutputExtensionError("vkGetAccelerationStructureHandleNV", VK_NV_RAY_TRACING_EXTENSION_NAME);
     skip |= validate_required_handle("vkGetAccelerationStructureHandleNV", "accelerationStructure", accelerationStructure);
     skip |= validate_array("vkGetAccelerationStructureHandleNV", "dataSize", "pData", dataSize, &pData, true, true, "VUID-vkGetAccelerationStructureHandleNV-dataSize-arraylength", "VUID-vkGetAccelerationStructureHandleNV-pData-parameter");
-    skip |= manual_PreCallValidateGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
+    if (!skip) skip |= manual_PreCallValidateGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData);
     return skip;
 }
 
@@ -9644,7 +9788,7 @@ bool StatelessValidation::PreCallValidateGetMemoryHostPointerPropertiesEXT(
     bool skip = false;
     if (!device_extensions.vk_khr_external_memory) skip |= OutputExtensionError("vkGetMemoryHostPointerPropertiesEXT", VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
     if (!device_extensions.vk_ext_external_memory_host) skip |= OutputExtensionError("vkGetMemoryHostPointerPropertiesEXT", VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME);
-    skip |= validate_flags("vkGetMemoryHostPointerPropertiesEXT", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, handleType, true, true, "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter");
+    skip |= validate_flags("vkGetMemoryHostPointerPropertiesEXT", "handleType", "VkExternalMemoryHandleTypeFlagBits", AllVkExternalMemoryHandleTypeFlagBits, handleType, kRequiredSingleBit, "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter", "VUID-vkGetMemoryHostPointerPropertiesEXT-handleType-parameter");
     skip |= validate_required_pointer("vkGetMemoryHostPointerPropertiesEXT", "pHostPointer", pHostPointer, kVUIDUndefined);
     skip |= validate_struct_type("vkGetMemoryHostPointerPropertiesEXT", "pMemoryHostPointerProperties", "VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT", pMemoryHostPointerProperties, VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT, true, "VUID-vkGetMemoryHostPointerPropertiesEXT-pMemoryHostPointerProperties-parameter", "VUID-VkMemoryHostPointerPropertiesEXT-sType-sType");
     if (pMemoryHostPointerProperties != NULL)
@@ -9664,13 +9808,15 @@ bool StatelessValidation::PreCallValidateCmdWriteBufferMarkerAMD(
     uint32_t                                    marker) {
     bool skip = false;
     if (!device_extensions.vk_amd_buffer_marker) skip |= OutputExtensionError("vkCmdWriteBufferMarkerAMD", VK_AMD_BUFFER_MARKER_EXTENSION_NAME);
-    skip |= validate_flags("vkCmdWriteBufferMarkerAMD", "pipelineStage", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pipelineStage, true, true, "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter");
+    skip |= validate_flags("vkCmdWriteBufferMarkerAMD", "pipelineStage", "VkPipelineStageFlagBits", AllVkPipelineStageFlagBits, pipelineStage, kRequiredSingleBit, "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter", "VUID-vkCmdWriteBufferMarkerAMD-pipelineStage-parameter");
     skip |= validate_required_handle("vkCmdWriteBufferMarkerAMD", "dstBuffer", dstBuffer);
     return skip;
 }
 
 
 
+
+
 bool StatelessValidation::PreCallValidateGetPhysicalDeviceCalibrateableTimeDomainsEXT(
     VkPhysicalDevice                            physicalDevice,
     uint32_t*                                   pTimeDomainCount,
@@ -9729,7 +9875,7 @@ bool StatelessValidation::PreCallValidateCmdDrawMeshTasksNV(
     if (!device_extensions.vk_khr_get_physical_device_properties_2) skip |= OutputExtensionError("vkCmdDrawMeshTasksNV", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
     if (!device_extensions.vk_nv_mesh_shader) skip |= OutputExtensionError("vkCmdDrawMeshTasksNV", VK_NV_MESH_SHADER_EXTENSION_NAME);
     // No xml-driven validation
-    skip |= manual_PreCallValidateCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
+    if (!skip) skip |= manual_PreCallValidateCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask);
     return skip;
 }
 
@@ -9743,7 +9889,7 @@ bool StatelessValidation::PreCallValidateCmdDrawMeshTasksIndirectNV(
     if (!device_extensions.vk_khr_get_physical_device_properties_2) skip |= OutputExtensionError("vkCmdDrawMeshTasksIndirectNV", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
     if (!device_extensions.vk_nv_mesh_shader) skip |= OutputExtensionError("vkCmdDrawMeshTasksIndirectNV", VK_NV_MESH_SHADER_EXTENSION_NAME);
     skip |= validate_required_handle("vkCmdDrawMeshTasksIndirectNV", "buffer", buffer);
-    skip |= manual_PreCallValidateCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
+    if (!skip) skip |= manual_PreCallValidateCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride);
     return skip;
 }
 
@@ -9760,7 +9906,7 @@ bool StatelessValidation::PreCallValidateCmdDrawMeshTasksIndirectCountNV(
     if (!device_extensions.vk_nv_mesh_shader) skip |= OutputExtensionError("vkCmdDrawMeshTasksIndirectCountNV", VK_NV_MESH_SHADER_EXTENSION_NAME);
     skip |= validate_required_handle("vkCmdDrawMeshTasksIndirectCountNV", "buffer", buffer);
     skip |= validate_required_handle("vkCmdDrawMeshTasksIndirectCountNV", "countBuffer", countBuffer);
-    skip |= manual_PreCallValidateCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
+    if (!skip) skip |= manual_PreCallValidateCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride);
     return skip;
 }
 
@@ -9788,7 +9934,7 @@ bool StatelessValidation::PreCallValidateCmdSetExclusiveScissorNV(
             // No xml-driven validation
         }
     }
-    skip |= manual_PreCallValidateCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
+    if (!skip) skip |= manual_PreCallValidateCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors);
     return skip;
 }
 
@@ -10058,6 +10204,12 @@ bool StatelessValidation::PreCallValidateCreateMetalSurfaceEXT(
 
 
 
+
+
+
+
+
+
 bool StatelessValidation::PreCallValidateGetBufferDeviceAddressEXT(
     VkDevice                                    device,
     const VkBufferDeviceAddressInfoEXT*         pInfo) {
@@ -10203,6 +10355,20 @@ bool StatelessValidation::PreCallValidateCreateHeadlessSurfaceEXT(
 
 
 
+bool StatelessValidation::PreCallValidateCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern) {
+    bool skip = false;
+    if (!device_extensions.vk_khr_get_physical_device_properties_2) skip |= OutputExtensionError("vkCmdSetLineStippleEXT", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    if (!device_extensions.vk_ext_line_rasterization) skip |= OutputExtensionError("vkCmdSetLineStippleEXT", VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME);
+    // No xml-driven validation
+    if (!skip) skip |= manual_PreCallValidateCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern);
+    return skip;
+}
+
+
+
 bool StatelessValidation::PreCallValidateResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
@@ -10222,3 +10388,5 @@ bool StatelessValidation::PreCallValidateResetQueryPoolEXT(
 
 
 
+
+
diff --git a/layers/generated/parameter_validation.h b/layers/generated/parameter_validation.h
index 41215764f..e2ceb5e17 100644
--- a/layers/generated/parameter_validation.h
+++ b/layers/generated/parameter_validation.h
@@ -1182,6 +1182,21 @@ bool PreCallValidateCmdDrawIndexedIndirectCountKHR(
     VkDeviceSize                                countBufferOffset,
     uint32_t                                    maxDrawCount,
     uint32_t                                    stride);
+bool PreCallValidateGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties);
+bool PreCallValidateGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics);
+bool PreCallValidateGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
 bool PreCallValidateCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -1731,6 +1746,10 @@ bool PreCallValidateCreateHeadlessSurfaceEXT(
     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
     const VkAllocationCallbacks*                pAllocator,
     VkSurfaceKHR*                               pSurface);
+bool PreCallValidateCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
 bool PreCallValidateResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
diff --git a/layers/generated/spirv_tools_commit_id.h b/layers/generated/spirv_tools_commit_id.h
index b41d57dc1..7404bf415 100644
--- a/layers/generated/spirv_tools_commit_id.h
+++ b/layers/generated/spirv_tools_commit_id.h
@@ -26,4 +26,4 @@
  ****************************************************************************/
 #pragma once
 
-#define SPIRV_TOOLS_COMMIT_ID "3a1bf2cb47845cd27db1a89f1b75b71cf7ec92f7"
+#define SPIRV_TOOLS_COMMIT_ID "333d1c95792692205472c457d7bec915a94c8000"
diff --git a/layers/generated/thread_safety.cpp b/layers/generated/thread_safety.cpp
index 502e8c580..e33f0060d 100644
--- a/layers/generated/thread_safety.cpp
+++ b/layers/generated/thread_safety.cpp
@@ -1,6 +1,6 @@
 
 // This file is ***GENERATED***.  Do Not Edit.
-// See layer_chassis_dispatch_generator.py for modifications.
+// See thread_safety_generator.py for modifications.
 
 /* Copyright (c) 2015-2019 The Khronos Group Inc.
  * Copyright (c) 2015-2019 Valve Corporation
@@ -38,9 +38,10 @@ void ThreadSafety::PostCallRecordAllocateCommandBuffers(VkDevice device, const V
 
     // Record mapping from command buffer to command pool
     if(pCommandBuffers) {
-        std::lock_guard<std::mutex> lock(command_pool_lock);
         for (uint32_t index = 0; index < pAllocateInfo->commandBufferCount; index++) {
-            command_pool_map[pCommandBuffers[index]] = pAllocateInfo->commandPool;
+            auto &bucket = GetBucket(pCommandBuffers[index]);
+            std::lock_guard<std::mutex> lock(bucket.command_pool_lock);
+            bucket.command_pool_map[pCommandBuffers[index]] = pAllocateInfo->commandPool;
         }
     }
 }
@@ -76,9 +77,10 @@ void ThreadSafety::PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPoo
             FinishWriteObject(pCommandBuffers[index], lockCommandPool);
         }
         // Holding the lock for the shortest time while we update the map
-        std::lock_guard<std::mutex> lock(command_pool_lock);
         for (uint32_t index = 0; index < commandBufferCount; index++) {
-            command_pool_map.erase(pCommandBuffers[index]);
+            auto &bucket = GetBucket(pCommandBuffers[index]);
+            std::lock_guard<std::mutex> lock(bucket.command_pool_lock);
+            bucket.command_pool_map.erase(pCommandBuffers[index]);
         }
     }
 }
@@ -3925,6 +3927,57 @@ void ThreadSafety::PostCallRecordCmdDrawIndexedIndirectCountKHR(
     // Host access to commandBuffer must be externally synchronized
 }
 
+void ThreadSafety::PreCallRecordGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties) {
+    StartReadObject(device);
+}
+
+void ThreadSafety::PostCallRecordGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties,
+    VkResult                                    result) {
+    FinishReadObject(device);
+}
+
+void ThreadSafety::PreCallRecordGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics) {
+    StartReadObject(device);
+}
+
+void ThreadSafety::PostCallRecordGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics,
+    VkResult                                    result) {
+    FinishReadObject(device);
+}
+
+void ThreadSafety::PreCallRecordGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) {
+    StartReadObject(device);
+}
+
+void ThreadSafety::PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations,
+    VkResult                                    result) {
+    FinishReadObject(device);
+}
+
 void ThreadSafety::PreCallRecordCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -5761,6 +5814,22 @@ void ThreadSafety::PostCallRecordCreateHeadlessSurfaceEXT(
     FinishReadObject(instance);
 }
 
+void ThreadSafety::PreCallRecordCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern) {
+    StartWriteObject(commandBuffer);
+    // Host access to commandBuffer must be externally synchronized
+}
+
+void ThreadSafety::PostCallRecordCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern) {
+    FinishWriteObject(commandBuffer);
+    // Host access to commandBuffer must be externally synchronized
+}
+
 void ThreadSafety::PreCallRecordResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
diff --git a/layers/generated/thread_safety.h b/layers/generated/thread_safety.h
index e20437759..a55fc704a 100644
--- a/layers/generated/thread_safety.h
+++ b/layers/generated/thread_safety.h
@@ -1,6 +1,6 @@
 
 // This file is ***GENERATED***.  Do Not Edit.
-// See layer_chassis_dispatch_generator.py for modifications.
+// See thread_safety_generator.py for modifications.
 
 /* Copyright (c) 2015-2019 The Khronos Group Inc.
  * Copyright (c) 2015-2019 Valve Corporation
@@ -24,7 +24,8 @@
 
 #pragma once
 
-#include <condition_variable>
+#include <chrono>
+#include <thread>
 #include <mutex>
 #include <vector>
 #include <unordered_set>
@@ -116,32 +117,53 @@ public:
     }
 };
 
+#define THREAD_SAFETY_BUCKETS_LOG2 6
+#define THREAD_SAFETY_BUCKETS (1 << THREAD_SAFETY_BUCKETS_LOG2)
+
+template <typename T> inline uint32_t ThreadSafetyHashObject(T object)
+{
+    uint64_t u64 = (uint64_t)(uintptr_t)object;
+    uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
+    hash ^= (hash >> THREAD_SAFETY_BUCKETS_LOG2) ^ (hash >> (2*THREAD_SAFETY_BUCKETS_LOG2));
+    hash &= (THREAD_SAFETY_BUCKETS-1);
+    return hash;
+}
+
 template <typename T>
 class counter {
 public:
     const char *typeName;
     VkDebugReportObjectTypeEXT objectType;
     debug_report_data **report_data;
-    small_unordered_map<T, object_use_data> uses;
-    std::mutex counter_lock;
-    std::condition_variable counter_condition;
 
+    // Per-bucket locking, to reduce contention.
+    struct CounterBucket {
+        small_unordered_map<T, object_use_data> uses;
+        std::mutex counter_lock;
+    };
+
+    CounterBucket buckets[THREAD_SAFETY_BUCKETS];
+    CounterBucket &GetBucket(T object)
+    {
+        return buckets[ThreadSafetyHashObject(object)];
+    }
 
     void StartWrite(T object) {
         if (object == VK_NULL_HANDLE) {
             return;
         }
+        auto &bucket = GetBucket(object);
         bool skip = false;
         loader_platform_thread_id tid = loader_platform_get_thread_id();
-        std::unique_lock<std::mutex> lock(counter_lock);
-        if (!uses.contains(object)) {
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        if (!bucket.uses.contains(object)) {
             // There is no current use of the object.  Record writer thread.
-            struct object_use_data *use_data = &uses[object];
+            struct object_use_data *use_data = &bucket.uses[object];
             use_data->reader_count = 0;
             use_data->writer_count = 1;
             use_data->thread = tid;
         } else {
-            struct object_use_data *use_data = &uses[object];
+            struct object_use_data *use_data = &bucket.uses[object];
             if (use_data->reader_count == 0) {
                 // There are no readers.  Two writers just collided.
                 if (use_data->thread != tid) {
@@ -151,12 +173,9 @@ public:
                         "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
                         typeName, (uint64_t)use_data->thread, (uint64_t)tid);
                     if (skip) {
-                        // Wait for thread-safe access to object instead of skipping call.
-                        while (uses.contains(object)) {
-                            counter_condition.wait(lock);
-                        }
+                        WaitForObjectIdle(bucket, object, lock);
                         // There is now no current use of the object.  Record writer thread.
-                        struct object_use_data *new_use_data = &uses[object];
+                        struct object_use_data *new_use_data = &bucket.uses[object];
                         new_use_data->thread = tid;
                         new_use_data->reader_count = 0;
                         new_use_data->writer_count = 1;
@@ -179,12 +198,9 @@ public:
                         "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
                         typeName, (uint64_t)use_data->thread, (uint64_t)tid);
                     if (skip) {
-                        // Wait for thread-safe access to object instead of skipping call.
-                        while (uses.contains(object)) {
-                            counter_condition.wait(lock);
-                        }
+                        WaitForObjectIdle(bucket, object, lock);
                         // There is now no current use of the object.  Record writer thread.
-                        struct object_use_data *new_use_data = &uses[object];
+                        struct object_use_data *new_use_data = &bucket.uses[object];
                         new_use_data->thread = tid;
                         new_use_data->reader_count = 0;
                         new_use_data->writer_count = 1;
@@ -206,73 +222,81 @@ public:
         if (object == VK_NULL_HANDLE) {
             return;
         }
+        auto &bucket = GetBucket(object);
         // Object is no longer in use
-        std::unique_lock<std::mutex> lock(counter_lock);
-        uses[object].writer_count -= 1;
-        if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
-            uses.erase(object);
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        struct object_use_data *use_data = &bucket.uses[object];
+        use_data->writer_count -= 1;
+        if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
+            bucket.uses.erase(object);
         }
-        // Notify any waiting threads that this object may be safe to use
-        lock.unlock();
-        counter_condition.notify_all();
     }
 
     void StartRead(T object) {
         if (object == VK_NULL_HANDLE) {
             return;
         }
+        auto &bucket = GetBucket(object);
         bool skip = false;
         loader_platform_thread_id tid = loader_platform_get_thread_id();
-        std::unique_lock<std::mutex> lock(counter_lock);
-        if (!uses.contains(object)) {
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        if (!bucket.uses.contains(object)) {
             // There is no current use of the object.  Record reader count
-            struct object_use_data *use_data = &uses[object];
+            struct object_use_data *use_data = &bucket.uses[object];
             use_data->reader_count = 1;
             use_data->writer_count = 0;
             use_data->thread = tid;
-        } else if (uses[object].writer_count > 0 && uses[object].thread != tid) {
+        } else if (bucket.uses[object].writer_count > 0 && bucket.uses[object].thread != tid) {
             // There is a writer of the object.
-            skip |= false;
-            log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), kVUID_Threading_MultipleThreads,
+            skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
+                kVUID_Threading_MultipleThreads,
                 "THREADING ERROR : object of type %s is simultaneously used in "
                 "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
-                typeName, (uint64_t)uses[object].thread, (uint64_t)tid);
+                typeName, (uint64_t)bucket.uses[object].thread, (uint64_t)tid);
             if (skip) {
-                // Wait for thread-safe access to object instead of skipping call.
-                while (uses.contains(object)) {
-                    counter_condition.wait(lock);
-                }
+                WaitForObjectIdle(bucket, object, lock);
                 // There is no current use of the object.  Record reader count
-                struct object_use_data *use_data = &uses[object];
+                struct object_use_data *use_data = &bucket.uses[object];
                 use_data->reader_count = 1;
                 use_data->writer_count = 0;
                 use_data->thread = tid;
             } else {
-                uses[object].reader_count += 1;
+                bucket.uses[object].reader_count += 1;
             }
         } else {
             // There are other readers of the object.  Increase reader count
-            uses[object].reader_count += 1;
+            bucket.uses[object].reader_count += 1;
         }
     }
     void FinishRead(T object) {
         if (object == VK_NULL_HANDLE) {
             return;
         }
-        std::unique_lock<std::mutex> lock(counter_lock);
-        uses[object].reader_count -= 1;
-        if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
-            uses.erase(object);
+        auto &bucket = GetBucket(object);
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        struct object_use_data *use_data = &bucket.uses[object];
+        use_data->reader_count -= 1;
+        if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
+            bucket.uses.erase(object);
         }
-        // Notify any waiting threads that this object may be safe to use
-        lock.unlock();
-        counter_condition.notify_all();
     }
     counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, debug_report_data **rep_data = nullptr) {
         typeName = name;
         objectType = type;
         report_data = rep_data;
     }
+
+private:
+    void WaitForObjectIdle(CounterBucket &bucket, T object, std::unique_lock<std::mutex> &lock) {
+        // Wait for thread-safe access to object instead of skipping call.
+        // Don't use condition_variable to wait because it should be extremely
+        // rare to have collisions, but signaling would be very frequent.
+        while (bucket.uses.contains(object)) {
+            lock.unlock();
+            std::this_thread::sleep_for(std::chrono::microseconds(1));
+            lock.lock();
+        }
+    }
 };
 
 
@@ -286,8 +310,17 @@ public:
         return std::unique_lock<std::mutex>(validation_object_mutex, std::defer_lock);
     }
 
-    std::mutex command_pool_lock;
-    std::unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;
+    // Per-bucket locking, to reduce contention.
+    struct CommandBufferBucket {
+        std::mutex command_pool_lock;
+        small_unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;
+    };
+
+    CommandBufferBucket buckets[THREAD_SAFETY_BUCKETS];
+    CommandBufferBucket &GetBucket(VkCommandBuffer object)
+    {
+        return buckets[ThreadSafetyHashObject(object)];
+    }
 
     counter<VkCommandBuffer> c_VkCommandBuffer;
     counter<VkDevice> c_VkDevice;
@@ -435,8 +468,9 @@ WRAPPER(uint64_t)
     // VkCommandBuffer needs check for implicit use of command pool
     void StartWriteObject(VkCommandBuffer object, bool lockPool = true) {
         if (lockPool) {
-            std::unique_lock<std::mutex> lock(command_pool_lock);
-            VkCommandPool pool = command_pool_map[object];
+            auto &bucket = GetBucket(object);
+            std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+            VkCommandPool pool = bucket.command_pool_map[object];
             lock.unlock();
             StartWriteObject(pool);
         }
@@ -445,15 +479,17 @@ WRAPPER(uint64_t)
     void FinishWriteObject(VkCommandBuffer object, bool lockPool = true) {
         c_VkCommandBuffer.FinishWrite(object);
         if (lockPool) {
-            std::unique_lock<std::mutex> lock(command_pool_lock);
-            VkCommandPool pool = command_pool_map[object];
+            auto &bucket = GetBucket(object);
+            std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+            VkCommandPool pool = bucket.command_pool_map[object];
             lock.unlock();
             FinishWriteObject(pool);
         }
     }
     void StartReadObject(VkCommandBuffer object) {
-        std::unique_lock<std::mutex> lock(command_pool_lock);
-        VkCommandPool pool = command_pool_map[object];
+        auto &bucket = GetBucket(object);
+        std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+        VkCommandPool pool = bucket.command_pool_map[object];
         lock.unlock();
         // We set up a read guard against the "Contents" counter to catch conflict vs. vkResetCommandPool and vkDestroyCommandPool
         // while *not* establishing a read guard against the command pool counter itself to avoid false postives for
@@ -462,9 +498,10 @@ WRAPPER(uint64_t)
         c_VkCommandBuffer.StartRead(object);
     }
     void FinishReadObject(VkCommandBuffer object) {
+        auto &bucket = GetBucket(object);
         c_VkCommandBuffer.FinishRead(object);
-        std::unique_lock<std::mutex> lock(command_pool_lock);
-        VkCommandPool pool = command_pool_map[object];
+        std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+        VkCommandPool pool = bucket.command_pool_map[object];
         lock.unlock();
         c_VkCommandPoolContents.FinishRead(pool);
     } 
@@ -2930,6 +2967,45 @@ void PostCallRecordCmdDrawIndexedIndirectCountKHR(
     uint32_t                                    maxDrawCount,
     uint32_t                                    stride);
 
+void PreCallRecordGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties);
+
+void PostCallRecordGetPipelineExecutablePropertiesKHR(
+    VkDevice                                    device,
+    const VkPipelineInfoKHR*                    pPipelineInfo,
+    uint32_t*                                   pExecutableCount,
+    VkPipelineExecutablePropertiesKHR*          pProperties,
+    VkResult                                    result);
+
+void PreCallRecordGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics);
+
+void PostCallRecordGetPipelineExecutableStatisticsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pStatisticCount,
+    VkPipelineExecutableStatisticKHR*           pStatistics,
+    VkResult                                    result);
+
+void PreCallRecordGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
+
+void PostCallRecordGetPipelineExecutableInternalRepresentationsKHR(
+    VkDevice                                    device,
+    const VkPipelineExecutableInfoKHR*          pExecutableInfo,
+    uint32_t*                                   pInternalRepresentationCount,
+    VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations,
+    VkResult                                    result);
+
 void PreCallRecordCreateDebugReportCallbackEXT(
     VkInstance                                  instance,
     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
@@ -4150,6 +4226,16 @@ void PostCallRecordCreateHeadlessSurfaceEXT(
     VkSurfaceKHR*                               pSurface,
     VkResult                                    result);
 
+void PreCallRecordCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
+
+void PostCallRecordCmdSetLineStippleEXT(
+    VkCommandBuffer                             commandBuffer,
+    uint32_t                                    lineStippleFactor,
+    uint16_t                                    lineStipplePattern);
+
 void PreCallRecordResetQueryPoolEXT(
     VkDevice                                    device,
     VkQueryPool                                 queryPool,
diff --git a/layers/generated/vk_dispatch_table_helper.h b/layers/generated/vk_dispatch_table_helper.h
index b5deb5663..fca72736d 100644
--- a/layers/generated/vk_dispatch_table_helper.h
+++ b/layers/generated/vk_dispatch_table_helper.h
@@ -106,6 +106,9 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubBindImageMemory2KHR(VkDevice device, u
 static VKAPI_ATTR void VKAPI_CALL StubGetDescriptorSetLayoutSupportKHR(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) {  };
 static VKAPI_ATTR void VKAPI_CALL StubCmdDrawIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {  };
 static VKAPI_ATTR void VKAPI_CALL StubCmdDrawIndexedIndirectCountKHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) {  };
+static VKAPI_ATTR VkResult VKAPI_CALL StubGetPipelineExecutablePropertiesKHR(VkDevice                        device, const VkPipelineInfoKHR*        pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) { return VK_SUCCESS; };
+static VKAPI_ATTR VkResult VKAPI_CALL StubGetPipelineExecutableStatisticsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) { return VK_SUCCESS; };
+static VKAPI_ATTR VkResult VKAPI_CALL StubGetPipelineExecutableInternalRepresentationsKHR(VkDevice                        device, const VkPipelineExecutableInfoKHR*  pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) { return VK_SUCCESS; };
 static VKAPI_ATTR VkResult VKAPI_CALL StubDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) { return VK_SUCCESS; };
 static VKAPI_ATTR VkResult VKAPI_CALL StubDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) { return VK_SUCCESS; };
 static VKAPI_ATTR void VKAPI_CALL StubCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) {  };
@@ -207,6 +210,7 @@ static VKAPI_ATTR VkResult VKAPI_CALL StubReleaseFullScreenExclusiveModeEXT(VkDe
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 static VKAPI_ATTR VkResult VKAPI_CALL StubGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) { return VK_SUCCESS; };
 #endif // VK_USE_PLATFORM_WIN32_KHR
+static VKAPI_ATTR void VKAPI_CALL StubCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) {  };
 static VKAPI_ATTR void VKAPI_CALL StubResetQueryPoolEXT(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) {  };
 
 
@@ -273,6 +277,9 @@ const std::unordered_map<std::string, std::string> api_extension_map {
     {"vkGetDescriptorSetLayoutSupportKHR", "VK_KHR_maintenance3"},
     {"vkCmdDrawIndirectCountKHR", "VK_KHR_draw_indirect_count"},
     {"vkCmdDrawIndexedIndirectCountKHR", "VK_KHR_draw_indirect_count"},
+    {"vkGetPipelineExecutablePropertiesKHR", "VK_KHR_pipeline_executable_properties"},
+    {"vkGetPipelineExecutableStatisticsKHR", "VK_KHR_pipeline_executable_properties"},
+    {"vkGetPipelineExecutableInternalRepresentationsKHR", "VK_KHR_pipeline_executable_properties"},
     {"vkDebugMarkerSetObjectTagEXT", "VK_EXT_debug_marker"},
     {"vkDebugMarkerSetObjectNameEXT", "VK_EXT_debug_marker"},
     {"vkCmdDebugMarkerBeginEXT", "VK_EXT_debug_marker"},
@@ -362,6 +369,7 @@ const std::unordered_map<std::string, std::string> api_extension_map {
     {"vkAcquireFullScreenExclusiveModeEXT", "VK_EXT_full_screen_exclusive"},
     {"vkReleaseFullScreenExclusiveModeEXT", "VK_EXT_full_screen_exclusive"},
     {"vkGetDeviceGroupSurfacePresentModes2EXT", "VK_EXT_full_screen_exclusive"},
+    {"vkCmdSetLineStippleEXT", "VK_EXT_line_rasterization"},
     {"vkResetQueryPoolEXT", "VK_EXT_host_query_reset"},
 };
 
@@ -642,6 +650,12 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp
     if (table->CmdDrawIndirectCountKHR == nullptr) { table->CmdDrawIndirectCountKHR = (PFN_vkCmdDrawIndirectCountKHR)StubCmdDrawIndirectCountKHR; }
     table->CmdDrawIndexedIndirectCountKHR = (PFN_vkCmdDrawIndexedIndirectCountKHR) gpa(device, "vkCmdDrawIndexedIndirectCountKHR");
     if (table->CmdDrawIndexedIndirectCountKHR == nullptr) { table->CmdDrawIndexedIndirectCountKHR = (PFN_vkCmdDrawIndexedIndirectCountKHR)StubCmdDrawIndexedIndirectCountKHR; }
+    table->GetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR) gpa(device, "vkGetPipelineExecutablePropertiesKHR");
+    if (table->GetPipelineExecutablePropertiesKHR == nullptr) { table->GetPipelineExecutablePropertiesKHR = (PFN_vkGetPipelineExecutablePropertiesKHR)StubGetPipelineExecutablePropertiesKHR; }
+    table->GetPipelineExecutableStatisticsKHR = (PFN_vkGetPipelineExecutableStatisticsKHR) gpa(device, "vkGetPipelineExecutableStatisticsKHR");
+    if (table->GetPipelineExecutableStatisticsKHR == nullptr) { table->GetPipelineExecutableStatisticsKHR = (PFN_vkGetPipelineExecutableStatisticsKHR)StubGetPipelineExecutableStatisticsKHR; }
+    table->GetPipelineExecutableInternalRepresentationsKHR = (PFN_vkGetPipelineExecutableInternalRepresentationsKHR) gpa(device, "vkGetPipelineExecutableInternalRepresentationsKHR");
+    if (table->GetPipelineExecutableInternalRepresentationsKHR == nullptr) { table->GetPipelineExecutableInternalRepresentationsKHR = (PFN_vkGetPipelineExecutableInternalRepresentationsKHR)StubGetPipelineExecutableInternalRepresentationsKHR; }
     table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT) gpa(device, "vkDebugMarkerSetObjectTagEXT");
     if (table->DebugMarkerSetObjectTagEXT == nullptr) { table->DebugMarkerSetObjectTagEXT = (PFN_vkDebugMarkerSetObjectTagEXT)StubDebugMarkerSetObjectTagEXT; }
     table->DebugMarkerSetObjectNameEXT = (PFN_vkDebugMarkerSetObjectNameEXT) gpa(device, "vkDebugMarkerSetObjectNameEXT");
@@ -832,6 +846,8 @@ static inline void layer_init_device_dispatch_table(VkDevice device, VkLayerDisp
     table->GetDeviceGroupSurfacePresentModes2EXT = (PFN_vkGetDeviceGroupSurfacePresentModes2EXT) gpa(device, "vkGetDeviceGroupSurfacePresentModes2EXT");
     if (table->GetDeviceGroupSurfacePresentModes2EXT == nullptr) { table->GetDeviceGroupSurfacePresentModes2EXT = (PFN_vkGetDeviceGroupSurfacePresentModes2EXT)StubGetDeviceGroupSurfacePresentModes2EXT; }
 #endif // VK_USE_PLATFORM_WIN32_KHR
+    table->CmdSetLineStippleEXT = (PFN_vkCmdSetLineStippleEXT) gpa(device, "vkCmdSetLineStippleEXT");
+    if (table->CmdSetLineStippleEXT == nullptr) { table->CmdSetLineStippleEXT = (PFN_vkCmdSetLineStippleEXT)StubCmdSetLineStippleEXT; }
     table->ResetQueryPoolEXT = (PFN_vkResetQueryPoolEXT) gpa(device, "vkResetQueryPoolEXT");
     if (table->ResetQueryPoolEXT == nullptr) { table->ResetQueryPoolEXT = (PFN_vkResetQueryPoolEXT)StubResetQueryPoolEXT; }
 }
diff --git a/layers/generated/vk_enum_string_helper.h b/layers/generated/vk_enum_string_helper.h
index 26180fba2..e73822802 100644
--- a/layers/generated/vk_enum_string_helper.h
+++ b/layers/generated/vk_enum_string_helper.h
@@ -35,6 +35,7 @@
 #pragma warning( disable : 4065 )
 #endif
 
+#include <string>
 #include <vulkan/vulkan.h>
 
 
@@ -488,6 +489,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
@@ -530,8 +533,6 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
@@ -556,10 +557,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
@@ -580,6 +587,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2:
@@ -604,16 +613,20 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV";
-        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL:
-            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
@@ -626,12 +639,18 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT";
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
+            return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
             return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT";
         case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
@@ -654,6 +673,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO:
             return "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+            return "VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD";
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
             return "VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV";
         case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
@@ -668,6 +689,16 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO:
             return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR";
+        case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR:
+            return "VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR";
         case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO:
             return "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO";
         case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:
@@ -678,6 +709,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
             return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT";
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:
             return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO";
         case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
@@ -690,6 +723,8 @@ static inline const char* string_VkStructureType(VkStructureType input_value)
             return "VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
             return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
+            return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT";
         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
             return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO";
         case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO:
@@ -917,58 +952,86 @@ static inline const char* string_VkFormat(VkFormat input_value)
             return "VK_FORMAT_A8B8G8R8_UNORM_PACK32";
         case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
             return "VK_FORMAT_A8B8G8R8_USCALED_PACK32";
+        case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_10x10_SRGB_BLOCK";
         case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_10x10_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_10x5_SRGB_BLOCK";
         case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_10x5_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_10x6_SRGB_BLOCK";
         case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_10x6_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_10x8_SRGB_BLOCK";
         case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_10x8_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK";
         case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_12x10_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK";
         case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_4x4_SRGB_BLOCK";
         case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_4x4_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_5x4_SRGB_BLOCK";
         case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_5x4_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_5x5_SRGB_BLOCK";
         case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_5x5_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_6x5_SRGB_BLOCK";
         case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_6x5_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_6x6_SRGB_BLOCK";
         case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_6x6_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_8x5_SRGB_BLOCK";
         case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_8x5_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_8x6_SRGB_BLOCK";
         case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
             return "VK_FORMAT_ASTC_8x6_UNORM_BLOCK";
+        case VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT:
+            return "VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT";
         case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
             return "VK_FORMAT_ASTC_8x8_SRGB_BLOCK";
         case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
@@ -1638,8 +1701,12 @@ static inline const char* string_VkMemoryPropertyFlagBits(VkMemoryPropertyFlagBi
 {
     switch ((VkMemoryPropertyFlagBits)input_value)
     {
+        case VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD:
+            return "VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD";
         case VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT:
             return "VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT";
+        case VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD:
+            return "VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD";
         case VK_MEMORY_PROPERTY_HOST_CACHED_BIT:
             return "VK_MEMORY_PROPERTY_HOST_CACHED_BIT";
         case VK_MEMORY_PROPERTY_HOST_COHERENT_BIT:
@@ -2256,6 +2323,10 @@ static inline const char* string_VkPipelineCreateFlagBits(VkPipelineCreateFlagBi
     {
         case VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT:
             return "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT";
+        case VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR:
+            return "VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR";
+        case VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR:
+            return "VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR";
         case VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV:
             return "VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV";
         case VK_PIPELINE_CREATE_DERIVATIVE_BIT:
@@ -2287,6 +2358,35 @@ static inline std::string string_VkPipelineCreateFlags(VkPipelineCreateFlags inp
     return ret;
 }
 
+static inline const char* string_VkPipelineShaderStageCreateFlagBits(VkPipelineShaderStageCreateFlagBits input_value)
+{
+    switch ((VkPipelineShaderStageCreateFlagBits)input_value)
+    {
+        case VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT:
+            return "VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT";
+        case VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT:
+            return "VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT";
+        default:
+            return "Unhandled VkPipelineShaderStageCreateFlagBits";
+    }
+}
+
+static inline std::string string_VkPipelineShaderStageCreateFlags(VkPipelineShaderStageCreateFlags input_value)
+{
+    std::string ret;
+    int index = 0;
+    while(input_value) {
+        if (input_value & 1) {
+            if( !ret.empty()) ret.append("|");
+            ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(1 << index)));
+        }
+        ++index;
+        input_value >>= 1;
+    }
+    if( ret.empty()) ret.append(string_VkPipelineShaderStageCreateFlagBits(static_cast<VkPipelineShaderStageCreateFlagBits>(0)));
+    return ret;
+}
+
 static inline const char* string_VkShaderStageFlagBits(VkShaderStageFlagBits input_value)
 {
     switch ((VkShaderStageFlagBits)input_value)
@@ -2747,6 +2847,8 @@ static inline const char* string_VkDynamicState(VkDynamicState input_value)
             return "VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT";
         case VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV:
             return "VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV";
+        case VK_DYNAMIC_STATE_LINE_STIPPLE_EXT:
+            return "VK_DYNAMIC_STATE_LINE_STIPPLE_EXT";
         case VK_DYNAMIC_STATE_LINE_WIDTH:
             return "VK_DYNAMIC_STATE_LINE_WIDTH";
         case VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT:
@@ -3362,10 +3464,10 @@ static inline const char* string_VkStencilFaceFlagBits(VkStencilFaceFlagBits inp
     {
         case VK_STENCIL_FACE_BACK_BIT:
             return "VK_STENCIL_FACE_BACK_BIT";
+        case VK_STENCIL_FACE_FRONT_AND_BACK:
+            return "VK_STENCIL_FACE_FRONT_AND_BACK";
         case VK_STENCIL_FACE_FRONT_BIT:
             return "VK_STENCIL_FACE_FRONT_BIT";
-        case VK_STENCIL_FRONT_AND_BACK:
-            return "VK_STENCIL_FRONT_AND_BACK";
         default:
             return "Unhandled VkStencilFaceFlagBits";
     }
@@ -3397,6 +3499,8 @@ static inline const char* string_VkIndexType(VkIndexType input_value)
             return "VK_INDEX_TYPE_UINT16";
         case VK_INDEX_TYPE_UINT32:
             return "VK_INDEX_TYPE_UINT32";
+        case VK_INDEX_TYPE_UINT8_EXT:
+            return "VK_INDEX_TYPE_UINT8_EXT";
         default:
             return "Unhandled VkIndexType";
     }
@@ -4632,6 +4736,21 @@ static inline const char* string_VkDriverIdKHR(VkDriverIdKHR input_value)
     }
 }
 
+static inline const char* string_VkShaderFloatControlsIndependenceKHR(VkShaderFloatControlsIndependenceKHR input_value)
+{
+    switch ((VkShaderFloatControlsIndependenceKHR)input_value)
+    {
+        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR:
+            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR";
+        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR:
+            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR";
+        case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR:
+            return "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR";
+        default:
+            return "Unhandled VkShaderFloatControlsIndependenceKHR";
+    }
+}
+
 static inline const char* string_VkResolveModeFlagBitsKHR(VkResolveModeFlagBitsKHR input_value)
 {
     switch ((VkResolveModeFlagBitsKHR)input_value)
@@ -4667,6 +4786,23 @@ static inline std::string string_VkResolveModeFlagsKHR(VkResolveModeFlagsKHR inp
     return ret;
 }
 
+static inline const char* string_VkPipelineExecutableStatisticFormatKHR(VkPipelineExecutableStatisticFormatKHR input_value)
+{
+    switch ((VkPipelineExecutableStatisticFormatKHR)input_value)
+    {
+        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR:
+            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR";
+        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR:
+            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR";
+        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR:
+            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR";
+        case VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR:
+            return "VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR";
+        default:
+            return "Unhandled VkPipelineExecutableStatisticFormatKHR";
+    }
+}
+
 static inline const char* string_VkDebugReportObjectTypeEXT(VkDebugReportObjectTypeEXT input_value)
 {
     switch ((VkDebugReportObjectTypeEXT)input_value)
@@ -5345,6 +5481,19 @@ static inline const char* string_VkCoarseSampleOrderTypeNV(VkCoarseSampleOrderTy
     }
 }
 
+static inline const char* string_VkAccelerationStructureTypeNV(VkAccelerationStructureTypeNV input_value)
+{
+    switch ((VkAccelerationStructureTypeNV)input_value)
+    {
+        case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV:
+            return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV";
+        case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV:
+            return "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV";
+        default:
+            return "Unhandled VkAccelerationStructureTypeNV";
+    }
+}
+
 static inline const char* string_VkRayTracingShaderGroupTypeNV(VkRayTracingShaderGroupTypeNV input_value)
 {
     switch ((VkRayTracingShaderGroupTypeNV)input_value)
@@ -5435,19 +5584,6 @@ static inline std::string string_VkGeometryInstanceFlagsNV(VkGeometryInstanceFla
     return ret;
 }
 
-static inline const char* string_VkAccelerationStructureTypeNV(VkAccelerationStructureTypeNV input_value)
-{
-    switch ((VkAccelerationStructureTypeNV)input_value)
-    {
-        case VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV:
-            return "VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV";
-        case VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV:
-            return "VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV";
-        default:
-            return "Unhandled VkAccelerationStructureTypeNV";
-    }
-}
-
 static inline const char* string_VkBuildAccelerationStructureFlagBitsNV(VkBuildAccelerationStructureFlagBitsNV input_value)
 {
     switch ((VkBuildAccelerationStructureFlagBitsNV)input_value)
@@ -5662,6 +5798,8 @@ static inline const char* string_VkValidationFeatureEnableEXT(VkValidationFeatur
 {
     switch ((VkValidationFeatureEnableEXT)input_value)
     {
+        case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT:
+            return "VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT";
         case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT:
             return "VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT";
         case VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT:
@@ -5776,6 +5914,23 @@ static inline const char* string_VkFullScreenExclusiveEXT(VkFullScreenExclusiveE
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
+static inline const char* string_VkLineRasterizationModeEXT(VkLineRasterizationModeEXT input_value)
+{
+    switch ((VkLineRasterizationModeEXT)input_value)
+    {
+        case VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT:
+            return "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT";
+        case VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT:
+            return "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT";
+        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT:
+            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT";
+        case VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT:
+            return "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT";
+        default:
+            return "Unhandled VkLineRasterizationModeEXT";
+    }
+}
+
 static inline const char * GetPhysDevFeatureString(uint32_t index) {
     const char * IndexToPhysDevFeatureString[] = {
         "robustBufferAccess",
diff --git a/layers/generated/vk_extension_helper.h b/layers/generated/vk_extension_helper.h
index 302f3f263..2047e6058 100644
--- a/layers/generated/vk_extension_helper.h
+++ b/layers/generated/vk_extension_helper.h
@@ -275,6 +275,7 @@ static const std::set<std::string> kInstanceExtensionNames = {
 struct DeviceExtensions : public InstanceExtensions {
     bool vk_feature_version_1_1{false};
     bool vk_amd_buffer_marker{false};
+    bool vk_amd_device_coherent_memory{false};
     bool vk_amd_display_native_hdr{false};
     bool vk_amd_draw_indirect_count{false};
     bool vk_amd_gcn_shader{false};
@@ -283,9 +284,11 @@ struct DeviceExtensions : public InstanceExtensions {
     bool vk_amd_memory_overallocation_behavior{false};
     bool vk_amd_mixed_attachment_samples{false};
     bool vk_amd_negative_viewport_height{false};
+    bool vk_amd_pipeline_compiler_control{false};
     bool vk_amd_rasterization_order{false};
     bool vk_amd_shader_ballot{false};
     bool vk_amd_shader_core_properties{false};
+    bool vk_amd_shader_core_properties_2{false};
     bool vk_amd_shader_explicit_vertex_parameter{false};
     bool vk_amd_shader_fragment_mask{false};
     bool vk_amd_shader_image_load_store_lod{false};
@@ -315,7 +318,9 @@ struct DeviceExtensions : public InstanceExtensions {
     bool vk_ext_hdr_metadata{false};
     bool vk_ext_host_query_reset{false};
     bool vk_ext_image_drm_format_modifier{false};
+    bool vk_ext_index_type_uint8{false};
     bool vk_ext_inline_uniform_block{false};
+    bool vk_ext_line_rasterization{false};
     bool vk_ext_memory_budget{false};
     bool vk_ext_memory_priority{false};
     bool vk_ext_pci_bus_info{false};
@@ -331,7 +336,9 @@ struct DeviceExtensions : public InstanceExtensions {
     bool vk_ext_shader_subgroup_ballot{false};
     bool vk_ext_shader_subgroup_vote{false};
     bool vk_ext_shader_viewport_index_layer{false};
+    bool vk_ext_subgroup_size_control{false};
     bool vk_ext_texel_buffer_alignment{false};
+    bool vk_ext_texture_compression_astc_hdr{false};
     bool vk_ext_transform_feedback{false};
     bool vk_ext_validation_cache{false};
     bool vk_ext_vertex_attribute_divisor{false};
@@ -343,7 +350,7 @@ struct DeviceExtensions : public InstanceExtensions {
     bool vk_img_filter_cubic{false};
     bool vk_img_format_pvrtc{false};
     bool vk_intel_performance_query{false};
-    bool vk_intel_shader_integer_functions2{false};
+    bool vk_intel_shader_integer_functions_2{false};
     bool vk_khr_16bit_storage{false};
     bool vk_khr_8bit_storage{false};
     bool vk_khr_bind_memory_2{false};
@@ -372,6 +379,7 @@ struct DeviceExtensions : public InstanceExtensions {
     bool vk_khr_maintenance2{false};
     bool vk_khr_maintenance3{false};
     bool vk_khr_multiview{false};
+    bool vk_khr_pipeline_executable_properties{false};
     bool vk_khr_push_descriptor{false};
     bool vk_khr_relaxed_block_layout{false};
     bool vk_khr_sampler_mirror_clamp_to_edge{false};
@@ -436,6 +444,7 @@ struct DeviceExtensions : public InstanceExtensions {
         static const DeviceInfoMap info_map = {
             std::make_pair("VK_VERSION_1_1", DeviceInfo(&DeviceExtensions::vk_feature_version_1_1, {})),
             std::make_pair(VK_AMD_BUFFER_MARKER_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_buffer_marker, {})),
+            std::make_pair(VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_device_coherent_memory, {})),
             std::make_pair(VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_display_native_hdr, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME},
                            {&DeviceExtensions::vk_khr_get_surface_capabilities_2, VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME},
@@ -447,10 +456,13 @@ struct DeviceExtensions : public InstanceExtensions {
             std::make_pair(VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_memory_overallocation_behavior, {})),
             std::make_pair(VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_mixed_attachment_samples, {})),
             std::make_pair(VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_negative_viewport_height, {})),
+            std::make_pair(VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_pipeline_compiler_control, {})),
             std::make_pair(VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_rasterization_order, {})),
             std::make_pair(VK_AMD_SHADER_BALLOT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_shader_ballot, {})),
             std::make_pair(VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_shader_core_properties, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
+            std::make_pair(VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_shader_core_properties_2, {{
+                           {&DeviceExtensions::vk_amd_shader_core_properties, VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME}}})),
             std::make_pair(VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_shader_explicit_vertex_parameter, {})),
             std::make_pair(VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_shader_fragment_mask, {})),
             std::make_pair(VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_amd_shader_image_load_store_lod, {})),
@@ -512,9 +524,12 @@ struct DeviceExtensions : public InstanceExtensions {
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME},
                            {&DeviceExtensions::vk_khr_image_format_list, VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME},
                            {&DeviceExtensions::vk_khr_sampler_ycbcr_conversion, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME}}})),
+            std::make_pair(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_index_type_uint8, {})),
             std::make_pair(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_inline_uniform_block, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME},
                            {&DeviceExtensions::vk_khr_maintenance1, VK_KHR_MAINTENANCE1_EXTENSION_NAME}}})),
+            std::make_pair(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_line_rasterization, {{
+                           {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
             std::make_pair(VK_EXT_MEMORY_BUDGET_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_memory_budget, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
             std::make_pair(VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_memory_priority, {{
@@ -538,8 +553,11 @@ struct DeviceExtensions : public InstanceExtensions {
             std::make_pair(VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_shader_subgroup_ballot, {})),
             std::make_pair(VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_shader_subgroup_vote, {})),
             std::make_pair(VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_shader_viewport_index_layer, {})),
+            std::make_pair(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_subgroup_size_control, {})),
             std::make_pair(VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_texel_buffer_alignment, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
+            std::make_pair(VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_texture_compression_astc_hdr, {{
+                           {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
             std::make_pair(VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_transform_feedback, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
             std::make_pair(VK_EXT_VALIDATION_CACHE_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_ext_validation_cache, {})),
@@ -559,7 +577,7 @@ struct DeviceExtensions : public InstanceExtensions {
             std::make_pair(VK_IMG_FILTER_CUBIC_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_img_filter_cubic, {})),
             std::make_pair(VK_IMG_FORMAT_PVRTC_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_img_format_pvrtc, {})),
             std::make_pair(VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_intel_performance_query, {})),
-            std::make_pair(VK_INTEL_SHADER_INTEGER_FUNCTIONS2_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_intel_shader_integer_functions2, {{
+            std::make_pair(VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_intel_shader_integer_functions_2, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
             std::make_pair(VK_KHR_16BIT_STORAGE_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_16bit_storage, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME},
@@ -621,6 +639,7 @@ struct DeviceExtensions : public InstanceExtensions {
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
             std::make_pair(VK_KHR_MULTIVIEW_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_multiview, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
+            std::make_pair(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_pipeline_executable_properties, {})),
             std::make_pair(VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_push_descriptor, {{
                            {&DeviceExtensions::vk_khr_get_physical_device_properties_2, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME}}})),
             std::make_pair(VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME, DeviceInfo(&DeviceExtensions::vk_khr_relaxed_block_layout, {})),
@@ -774,6 +793,7 @@ struct DeviceExtensions : public InstanceExtensions {
 
 static const std::set<std::string> kDeviceExtensionNames = {
     VK_AMD_BUFFER_MARKER_EXTENSION_NAME,
+    VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME,
     VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME,
     VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME,
     VK_AMD_GCN_SHADER_EXTENSION_NAME,
@@ -782,9 +802,11 @@ static const std::set<std::string> kDeviceExtensionNames = {
     VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME,
     VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME,
     VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME,
+    VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME,
     VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME,
     VK_AMD_SHADER_BALLOT_EXTENSION_NAME,
     VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME,
+    VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME,
     VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME,
     VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME,
     VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME,
@@ -818,7 +840,9 @@ static const std::set<std::string> kDeviceExtensionNames = {
     VK_EXT_HDR_METADATA_EXTENSION_NAME,
     VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME,
     VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME,
+    VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME,
     VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME,
+    VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME,
     VK_EXT_MEMORY_BUDGET_EXTENSION_NAME,
     VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME,
     VK_EXT_PCI_BUS_INFO_EXTENSION_NAME,
@@ -834,7 +858,9 @@ static const std::set<std::string> kDeviceExtensionNames = {
     VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME,
     VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME,
     VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME,
+    VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME,
     VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME,
+    VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME,
     VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME,
     VK_EXT_VALIDATION_CACHE_EXTENSION_NAME,
     VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
@@ -848,7 +874,7 @@ static const std::set<std::string> kDeviceExtensionNames = {
     VK_IMG_FILTER_CUBIC_EXTENSION_NAME,
     VK_IMG_FORMAT_PVRTC_EXTENSION_NAME,
     VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME,
-    VK_INTEL_SHADER_INTEGER_FUNCTIONS2_EXTENSION_NAME,
+    VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME,
     VK_KHR_16BIT_STORAGE_EXTENSION_NAME,
     VK_KHR_8BIT_STORAGE_EXTENSION_NAME,
     VK_KHR_BIND_MEMORY_2_EXTENSION_NAME,
@@ -883,6 +909,7 @@ static const std::set<std::string> kDeviceExtensionNames = {
     VK_KHR_MAINTENANCE2_EXTENSION_NAME,
     VK_KHR_MAINTENANCE3_EXTENSION_NAME,
     VK_KHR_MULTIVIEW_EXTENSION_NAME,
+    VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME,
     VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
     VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME,
     VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME,
diff --git a/layers/generated/vk_layer_dispatch_table.h b/layers/generated/vk_layer_dispatch_table.h
index a95cc5757..3aed0c5eb 100644
--- a/layers/generated/vk_layer_dispatch_table.h
+++ b/layers/generated/vk_layer_dispatch_table.h
@@ -470,6 +470,11 @@ typedef struct VkLayerDispatchTable_ {
     PFN_vkCmdDrawIndirectCountKHR CmdDrawIndirectCountKHR;
     PFN_vkCmdDrawIndexedIndirectCountKHR CmdDrawIndexedIndirectCountKHR;
 
+    // ---- VK_KHR_pipeline_executable_properties extension commands
+    PFN_vkGetPipelineExecutablePropertiesKHR GetPipelineExecutablePropertiesKHR;
+    PFN_vkGetPipelineExecutableStatisticsKHR GetPipelineExecutableStatisticsKHR;
+    PFN_vkGetPipelineExecutableInternalRepresentationsKHR GetPipelineExecutableInternalRepresentationsKHR;
+
     // ---- VK_EXT_debug_marker extension commands
     PFN_vkDebugMarkerSetObjectTagEXT DebugMarkerSetObjectTagEXT;
     PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectNameEXT;
@@ -631,6 +636,9 @@ typedef struct VkLayerDispatchTable_ {
     PFN_vkGetDeviceGroupSurfacePresentModes2EXT GetDeviceGroupSurfacePresentModes2EXT;
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
+    // ---- VK_EXT_line_rasterization extension commands
+    PFN_vkCmdSetLineStippleEXT CmdSetLineStippleEXT;
+
     // ---- VK_EXT_host_query_reset extension commands
     PFN_vkResetQueryPoolEXT ResetQueryPoolEXT;
 } VkLayerDispatchTable;
diff --git a/layers/generated/vk_object_types.h b/layers/generated/vk_object_types.h
index 0e050db2c..6ff6ed99f 100644
--- a/layers/generated/vk_object_types.h
+++ b/layers/generated/vk_object_types.h
@@ -210,177 +210,92 @@ const VkObjectType get_object_type_enum[] = {
     VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL,   // kVulkanObjectTypePerformanceConfigurationINTEL
 };
 
-// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType
-static inline VkObjectType convertDebugReportObjectToCoreObject(VkDebugReportObjectTypeEXT debug_report_obj){
-    if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {
-        return VK_OBJECT_TYPE_UNKNOWN;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {
-        return VK_OBJECT_TYPE_UNKNOWN;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT) {
-        return VK_OBJECT_TYPE_INSTANCE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) {
-        return VK_OBJECT_TYPE_PHYSICAL_DEVICE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT) {
-        return VK_OBJECT_TYPE_DEVICE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT) {
-        return VK_OBJECT_TYPE_QUEUE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT) {
-        return VK_OBJECT_TYPE_SEMAPHORE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT) {
-        return VK_OBJECT_TYPE_COMMAND_BUFFER;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT) {
-        return VK_OBJECT_TYPE_FENCE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT) {
-        return VK_OBJECT_TYPE_DEVICE_MEMORY;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT) {
-        return VK_OBJECT_TYPE_BUFFER;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT) {
-        return VK_OBJECT_TYPE_IMAGE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT) {
-        return VK_OBJECT_TYPE_EVENT;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT) {
-        return VK_OBJECT_TYPE_QUERY_POOL;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT) {
-        return VK_OBJECT_TYPE_BUFFER_VIEW;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT) {
-        return VK_OBJECT_TYPE_IMAGE_VIEW;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT) {
-        return VK_OBJECT_TYPE_SHADER_MODULE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT) {
-        return VK_OBJECT_TYPE_PIPELINE_CACHE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT) {
-        return VK_OBJECT_TYPE_PIPELINE_LAYOUT;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT) {
-        return VK_OBJECT_TYPE_RENDER_PASS;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT) {
-        return VK_OBJECT_TYPE_PIPELINE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT) {
-        return VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT) {
-        return VK_OBJECT_TYPE_SAMPLER;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT) {
-        return VK_OBJECT_TYPE_DESCRIPTOR_POOL;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT) {
-        return VK_OBJECT_TYPE_DESCRIPTOR_SET;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT) {
-        return VK_OBJECT_TYPE_FRAMEBUFFER;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT) {
-        return VK_OBJECT_TYPE_COMMAND_POOL;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT) {
-        return VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT) {
-        return VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) {
-        return VK_OBJECT_TYPE_SURFACE_KHR;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT) {
-        return VK_OBJECT_TYPE_SWAPCHAIN_KHR;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT) {
-        return VK_OBJECT_TYPE_DISPLAY_KHR;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT) {
-        return VK_OBJECT_TYPE_DISPLAY_MODE_KHR;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT) {
-        return VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT) {
-        return VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT) {
-        return VK_OBJECT_TYPE_OBJECT_TABLE_NVX;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT) {
-        return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT) {
-        return VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT) {
-        return VK_OBJECT_TYPE_VALIDATION_CACHE_EXT;
-    } else if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT) {
-        return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV;
-    }
-    return VK_OBJECT_TYPE_UNKNOWN;
+static inline VkObjectType convertDebugReportObjectToCoreObject(VkDebugReportObjectTypeEXT debug_report_obj) {
+    switch (debug_report_obj) {
+        case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: return VK_OBJECT_TYPE_UNKNOWN;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: return VK_OBJECT_TYPE_INSTANCE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: return VK_OBJECT_TYPE_PHYSICAL_DEVICE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: return VK_OBJECT_TYPE_DEVICE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: return VK_OBJECT_TYPE_QUEUE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: return VK_OBJECT_TYPE_SEMAPHORE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: return VK_OBJECT_TYPE_COMMAND_BUFFER;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: return VK_OBJECT_TYPE_FENCE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: return VK_OBJECT_TYPE_DEVICE_MEMORY;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: return VK_OBJECT_TYPE_BUFFER;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: return VK_OBJECT_TYPE_IMAGE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: return VK_OBJECT_TYPE_EVENT;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: return VK_OBJECT_TYPE_QUERY_POOL;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: return VK_OBJECT_TYPE_BUFFER_VIEW;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: return VK_OBJECT_TYPE_IMAGE_VIEW;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: return VK_OBJECT_TYPE_SHADER_MODULE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: return VK_OBJECT_TYPE_PIPELINE_CACHE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: return VK_OBJECT_TYPE_PIPELINE_LAYOUT;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: return VK_OBJECT_TYPE_RENDER_PASS;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: return VK_OBJECT_TYPE_PIPELINE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: return VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: return VK_OBJECT_TYPE_SAMPLER;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: return VK_OBJECT_TYPE_DESCRIPTOR_POOL;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: return VK_OBJECT_TYPE_DESCRIPTOR_SET;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: return VK_OBJECT_TYPE_FRAMEBUFFER;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: return VK_OBJECT_TYPE_COMMAND_POOL;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: return VK_OBJECT_TYPE_SURFACE_KHR;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: return VK_OBJECT_TYPE_SWAPCHAIN_KHR;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: return VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: return VK_OBJECT_TYPE_DISPLAY_KHR;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: return VK_OBJECT_TYPE_DISPLAY_MODE_KHR;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT: return VK_OBJECT_TYPE_OBJECT_TABLE_NVX;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT: return VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: return VK_OBJECT_TYPE_VALIDATION_CACHE_EXT;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: return VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: return VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
+        case VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: return VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV;
+        default: return VK_OBJECT_TYPE_UNKNOWN;
+    }
 }
 
-// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType
-static inline VkDebugReportObjectTypeEXT convertCoreObjectToDebugReportObject(VkObjectType core_report_obj){
-    if (core_report_obj == VK_OBJECT_TYPE_UNKNOWN) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_UNKNOWN) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_INSTANCE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_PHYSICAL_DEVICE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DEVICE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_QUEUE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_SEMAPHORE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_COMMAND_BUFFER) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_FENCE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DEVICE_MEMORY) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_BUFFER) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_IMAGE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_EVENT) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_QUERY_POOL) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_BUFFER_VIEW) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_IMAGE_VIEW) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_SHADER_MODULE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_PIPELINE_CACHE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_PIPELINE_LAYOUT) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_RENDER_PASS) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_PIPELINE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_SAMPLER) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DESCRIPTOR_POOL) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DESCRIPTOR_SET) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_FRAMEBUFFER) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_COMMAND_POOL) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_SURFACE_KHR) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_SWAPCHAIN_KHR) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DISPLAY_KHR) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DISPLAY_MODE_KHR) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_OBJECT_TABLE_NVX) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_VALIDATION_CACHE_EXT) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT;
-    } else if (core_report_obj == VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV) {
-        return VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT;
-    }
-    return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
+static inline VkDebugReportObjectTypeEXT convertCoreObjectToDebugReportObject(VkObjectType core_report_obj) {
+    switch (core_report_obj) {
+        case VK_OBJECT_TYPE_UNKNOWN: return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
+        case VK_OBJECT_TYPE_INSTANCE: return VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT;
+        case VK_OBJECT_TYPE_PHYSICAL_DEVICE: return VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT;
+        case VK_OBJECT_TYPE_DEVICE: return VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT;
+        case VK_OBJECT_TYPE_QUEUE: return VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT;
+        case VK_OBJECT_TYPE_SEMAPHORE: return VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT;
+        case VK_OBJECT_TYPE_COMMAND_BUFFER: return VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT;
+        case VK_OBJECT_TYPE_FENCE: return VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT;
+        case VK_OBJECT_TYPE_DEVICE_MEMORY: return VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT;
+        case VK_OBJECT_TYPE_BUFFER: return VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT;
+        case VK_OBJECT_TYPE_IMAGE: return VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT;
+        case VK_OBJECT_TYPE_EVENT: return VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT;
+        case VK_OBJECT_TYPE_QUERY_POOL: return VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT;
+        case VK_OBJECT_TYPE_BUFFER_VIEW: return VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT;
+        case VK_OBJECT_TYPE_IMAGE_VIEW: return VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT;
+        case VK_OBJECT_TYPE_SHADER_MODULE: return VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT;
+        case VK_OBJECT_TYPE_PIPELINE_CACHE: return VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT;
+        case VK_OBJECT_TYPE_PIPELINE_LAYOUT: return VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT;
+        case VK_OBJECT_TYPE_RENDER_PASS: return VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT;
+        case VK_OBJECT_TYPE_PIPELINE: return VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT;
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT;
+        case VK_OBJECT_TYPE_SAMPLER: return VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT;
+        case VK_OBJECT_TYPE_DESCRIPTOR_POOL: return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT;
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET: return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT;
+        case VK_OBJECT_TYPE_FRAMEBUFFER: return VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT;
+        case VK_OBJECT_TYPE_COMMAND_POOL: return VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT;
+        case VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: return VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT;
+        case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: return VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT;
+        case VK_OBJECT_TYPE_SURFACE_KHR: return VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT;
+        case VK_OBJECT_TYPE_SWAPCHAIN_KHR: return VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT;
+        case VK_OBJECT_TYPE_DISPLAY_KHR: return VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT;
+        case VK_OBJECT_TYPE_DISPLAY_MODE_KHR: return VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT;
+        case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: return VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT;
+        case VK_OBJECT_TYPE_OBJECT_TABLE_NVX: return VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT;
+        case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX: return VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT;
+        case VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: return VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT;
+        case VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV: return VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT;
+        default: return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;
+    }
 }
+
 // Traits objects from each type statically map from Vk<handleType> to the various enums
 template <typename VkType> struct VkHandleInfo {};
 template <VulkanObjectType id> struct VulkanObjectTypeInfo {};
diff --git a/layers/generated/vk_safe_struct.cpp b/layers/generated/vk_safe_struct.cpp
index c7e602eb4..3ec4f4626 100644
--- a/layers/generated/vk_safe_struct.cpp
+++ b/layers/generated/vk_safe_struct.cpp
@@ -31,107 +31,141 @@
 
 
 #include "vk_safe_struct.h"
+
 #include <string.h>
+#include <cassert>
+#include <cstring>
+
+#include <vulkan/vk_layer.h>
 
 
 safe_VkApplicationInfo::safe_VkApplicationInfo(const VkApplicationInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
-    pApplicationName(in_struct->pApplicationName),
     applicationVersion(in_struct->applicationVersion),
-    pEngineName(in_struct->pEngineName),
     engineVersion(in_struct->engineVersion),
     apiVersion(in_struct->apiVersion)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pApplicationName = SafeStringCopy(in_struct->pApplicationName);
+    pEngineName = SafeStringCopy(in_struct->pEngineName);
 }
 
-safe_VkApplicationInfo::safe_VkApplicationInfo()
+safe_VkApplicationInfo::safe_VkApplicationInfo() :
+    pNext(nullptr),
+    pApplicationName(nullptr),
+    pEngineName(nullptr)
 {}
 
 safe_VkApplicationInfo::safe_VkApplicationInfo(const safe_VkApplicationInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
-    pApplicationName = src.pApplicationName;
     applicationVersion = src.applicationVersion;
-    pEngineName = src.pEngineName;
     engineVersion = src.engineVersion;
     apiVersion = src.apiVersion;
+    pNext = SafePnextCopy(src.pNext);
+    pApplicationName = SafeStringCopy(src.pApplicationName);
+    pEngineName = SafeStringCopy(src.pEngineName);
 }
 
 safe_VkApplicationInfo& safe_VkApplicationInfo::operator=(const safe_VkApplicationInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pApplicationName) delete [] pApplicationName;
+    if (pEngineName) delete [] pEngineName;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
-    pApplicationName = src.pApplicationName;
     applicationVersion = src.applicationVersion;
-    pEngineName = src.pEngineName;
     engineVersion = src.engineVersion;
     apiVersion = src.apiVersion;
+    pNext = SafePnextCopy(src.pNext);
+    pApplicationName = SafeStringCopy(src.pApplicationName);
+    pEngineName = SafeStringCopy(src.pEngineName);
 
     return *this;
 }
 
 safe_VkApplicationInfo::~safe_VkApplicationInfo()
 {
+    if (pApplicationName) delete [] pApplicationName;
+    if (pEngineName) delete [] pEngineName;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkApplicationInfo::initialize(const VkApplicationInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
-    pApplicationName = in_struct->pApplicationName;
     applicationVersion = in_struct->applicationVersion;
-    pEngineName = in_struct->pEngineName;
     engineVersion = in_struct->engineVersion;
     apiVersion = in_struct->apiVersion;
+    pNext = SafePnextCopy(in_struct->pNext);
+    pApplicationName = SafeStringCopy(in_struct->pApplicationName);
+    pEngineName = SafeStringCopy(in_struct->pEngineName);
 }
 
 void safe_VkApplicationInfo::initialize(const safe_VkApplicationInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
-    pApplicationName = src->pApplicationName;
     applicationVersion = src->applicationVersion;
-    pEngineName = src->pEngineName;
     engineVersion = src->engineVersion;
     apiVersion = src->apiVersion;
+    pNext = SafePnextCopy(src->pNext);
+    pApplicationName = SafeStringCopy(src->pApplicationName);
+    pEngineName = SafeStringCopy(src->pEngineName);
 }
 
 safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const VkInstanceCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
+    pApplicationInfo(nullptr),
     enabledLayerCount(in_struct->enabledLayerCount),
-    ppEnabledLayerNames(in_struct->ppEnabledLayerNames),
-    enabledExtensionCount(in_struct->enabledExtensionCount),
-    ppEnabledExtensionNames(in_struct->ppEnabledExtensionNames)
+    enabledExtensionCount(in_struct->enabledExtensionCount)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
+    char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (in_struct->pApplicationInfo)
         pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
-    else
-        pApplicationInfo = NULL;
 }
 
-safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo()
+safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo() :
+    pNext(nullptr),
+    pApplicationInfo(nullptr),
+    ppEnabledLayerNames(nullptr),
+    ppEnabledExtensionNames(nullptr)
 {}
 
 safe_VkInstanceCreateInfo::safe_VkInstanceCreateInfo(const safe_VkInstanceCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pApplicationInfo = nullptr;
     enabledLayerCount = src.enabledLayerCount;
-    ppEnabledLayerNames = src.ppEnabledLayerNames;
     enabledExtensionCount = src.enabledExtensionCount;
-    ppEnabledExtensionNames = src.ppEnabledExtensionNames;
+    pNext = SafePnextCopy(src.pNext);
+    char **tmp_ppEnabledLayerNames = new char *[src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (src.pApplicationInfo)
         pApplicationInfo = new safe_VkApplicationInfo(*src.pApplicationInfo);
-    else
-        pApplicationInfo = NULL;
 }
 
 safe_VkInstanceCreateInfo& safe_VkInstanceCreateInfo::operator=(const safe_VkInstanceCreateInfo& src)
@@ -140,18 +174,39 @@ safe_VkInstanceCreateInfo& safe_VkInstanceCreateInfo::operator=(const safe_VkIns
 
     if (pApplicationInfo)
         delete pApplicationInfo;
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete [] ppEnabledLayerNames[i];
+        }
+        delete [] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete [] ppEnabledExtensionNames[i];
+        }
+        delete [] ppEnabledExtensionNames;
+    }
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pApplicationInfo = nullptr;
     enabledLayerCount = src.enabledLayerCount;
-    ppEnabledLayerNames = src.ppEnabledLayerNames;
     enabledExtensionCount = src.enabledExtensionCount;
-    ppEnabledExtensionNames = src.ppEnabledExtensionNames;
+    pNext = SafePnextCopy(src.pNext);
+    char **tmp_ppEnabledLayerNames = new char *[src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (src.pApplicationInfo)
         pApplicationInfo = new safe_VkApplicationInfo(*src.pApplicationInfo);
-    else
-        pApplicationInfo = NULL;
 
     return *this;
 }
@@ -160,36 +215,64 @@ safe_VkInstanceCreateInfo::~safe_VkInstanceCreateInfo()
 {
     if (pApplicationInfo)
         delete pApplicationInfo;
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete [] ppEnabledLayerNames[i];
+        }
+        delete [] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete [] ppEnabledExtensionNames[i];
+        }
+        delete [] ppEnabledExtensionNames;
+    }
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkInstanceCreateInfo::initialize(const VkInstanceCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
+    pApplicationInfo = nullptr;
     enabledLayerCount = in_struct->enabledLayerCount;
-    ppEnabledLayerNames = in_struct->ppEnabledLayerNames;
     enabledExtensionCount = in_struct->enabledExtensionCount;
-    ppEnabledExtensionNames = in_struct->ppEnabledExtensionNames;
+    pNext = SafePnextCopy(in_struct->pNext);
+    char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (in_struct->pApplicationInfo)
         pApplicationInfo = new safe_VkApplicationInfo(in_struct->pApplicationInfo);
-    else
-        pApplicationInfo = NULL;
 }
 
 void safe_VkInstanceCreateInfo::initialize(const safe_VkInstanceCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
+    pApplicationInfo = nullptr;
     enabledLayerCount = src->enabledLayerCount;
-    ppEnabledLayerNames = src->ppEnabledLayerNames;
     enabledExtensionCount = src->enabledExtensionCount;
-    ppEnabledExtensionNames = src->ppEnabledExtensionNames;
+    pNext = SafePnextCopy(src->pNext);
+    char **tmp_ppEnabledLayerNames = new char *[src->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(src->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[src->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(src->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (src->pApplicationInfo)
         pApplicationInfo = new safe_VkApplicationInfo(*src->pApplicationInfo);
-    else
-        pApplicationInfo = NULL;
 }
 
 safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const VkAllocationCallbacks* in_struct) :
@@ -202,7 +285,8 @@ safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const VkAllocationCallbac
 {
 }
 
-safe_VkAllocationCallbacks::safe_VkAllocationCallbacks()
+safe_VkAllocationCallbacks::safe_VkAllocationCallbacks() :
+    pUserData(nullptr)
 {}
 
 safe_VkAllocationCallbacks::safe_VkAllocationCallbacks(const safe_VkAllocationCallbacks& src)
@@ -256,12 +340,12 @@ void safe_VkAllocationCallbacks::initialize(const safe_VkAllocationCallbacks* sr
 
 safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     queueFamilyIndex(in_struct->queueFamilyIndex),
     queueCount(in_struct->queueCount),
     pQueuePriorities(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueuePriorities) {
         pQueuePriorities = new float[in_struct->queueCount];
         memcpy ((void *)pQueuePriorities, (void *)in_struct->pQueuePriorities, sizeof(float)*in_struct->queueCount);
@@ -269,17 +353,18 @@ safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const VkDeviceQueueCr
 }
 
 safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo() :
+    pNext(nullptr),
     pQueuePriorities(nullptr)
 {}
 
 safe_VkDeviceQueueCreateInfo::safe_VkDeviceQueueCreateInfo(const safe_VkDeviceQueueCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueFamilyIndex = src.queueFamilyIndex;
     queueCount = src.queueCount;
     pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueuePriorities) {
         pQueuePriorities = new float[src.queueCount];
         memcpy ((void *)pQueuePriorities, (void *)src.pQueuePriorities, sizeof(float)*src.queueCount);
@@ -292,13 +377,15 @@ safe_VkDeviceQueueCreateInfo& safe_VkDeviceQueueCreateInfo::operator=(const safe
 
     if (pQueuePriorities)
         delete[] pQueuePriorities;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueFamilyIndex = src.queueFamilyIndex;
     queueCount = src.queueCount;
     pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueuePriorities) {
         pQueuePriorities = new float[src.queueCount];
         memcpy ((void *)pQueuePriorities, (void *)src.pQueuePriorities, sizeof(float)*src.queueCount);
@@ -311,16 +398,18 @@ safe_VkDeviceQueueCreateInfo::~safe_VkDeviceQueueCreateInfo()
 {
     if (pQueuePriorities)
         delete[] pQueuePriorities;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceQueueCreateInfo::initialize(const VkDeviceQueueCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     queueFamilyIndex = in_struct->queueFamilyIndex;
     queueCount = in_struct->queueCount;
     pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueuePriorities) {
         pQueuePriorities = new float[in_struct->queueCount];
         memcpy ((void *)pQueuePriorities, (void *)in_struct->pQueuePriorities, sizeof(float)*in_struct->queueCount);
@@ -330,11 +419,11 @@ void safe_VkDeviceQueueCreateInfo::initialize(const VkDeviceQueueCreateInfo* in_
 void safe_VkDeviceQueueCreateInfo::initialize(const safe_VkDeviceQueueCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     queueFamilyIndex = src->queueFamilyIndex;
     queueCount = src->queueCount;
     pQueuePriorities = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pQueuePriorities) {
         pQueuePriorities = new float[src->queueCount];
         memcpy ((void *)pQueuePriorities, (void *)src->pQueuePriorities, sizeof(float)*src->queueCount);
@@ -343,19 +432,27 @@ void safe_VkDeviceQueueCreateInfo::initialize(const safe_VkDeviceQueueCreateInfo
 
 safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     queueCreateInfoCount(in_struct->queueCreateInfoCount),
     pQueueCreateInfos(nullptr),
     enabledLayerCount(in_struct->enabledLayerCount),
-    ppEnabledLayerNames(in_struct->ppEnabledLayerNames),
     enabledExtensionCount(in_struct->enabledExtensionCount),
-    ppEnabledExtensionNames(in_struct->ppEnabledExtensionNames),
     pEnabledFeatures(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
+    char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
         pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
-        for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
             pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
         }
     }
@@ -365,25 +462,36 @@ safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const VkDeviceCreateInfo* in_st
 }
 
 safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo() :
+    pNext(nullptr),
     pQueueCreateInfos(nullptr),
+    ppEnabledLayerNames(nullptr),
+    ppEnabledExtensionNames(nullptr),
     pEnabledFeatures(nullptr)
 {}
 
 safe_VkDeviceCreateInfo::safe_VkDeviceCreateInfo(const safe_VkDeviceCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueCreateInfoCount = src.queueCreateInfoCount;
     pQueueCreateInfos = nullptr;
     enabledLayerCount = src.enabledLayerCount;
-    ppEnabledLayerNames = src.ppEnabledLayerNames;
     enabledExtensionCount = src.enabledExtensionCount;
-    ppEnabledExtensionNames = src.ppEnabledExtensionNames;
     pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(src.pNext);
+    char **tmp_ppEnabledLayerNames = new char *[src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (queueCreateInfoCount && src.pQueueCreateInfos) {
         pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
-        for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
             pQueueCreateInfos[i].initialize(&src.pQueueCreateInfos[i]);
         }
     }
@@ -398,22 +506,44 @@ safe_VkDeviceCreateInfo& safe_VkDeviceCreateInfo::operator=(const safe_VkDeviceC
 
     if (pQueueCreateInfos)
         delete[] pQueueCreateInfos;
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete [] ppEnabledLayerNames[i];
+        }
+        delete [] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete [] ppEnabledExtensionNames[i];
+        }
+        delete [] ppEnabledExtensionNames;
+    }
     if (pEnabledFeatures)
         delete pEnabledFeatures;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueCreateInfoCount = src.queueCreateInfoCount;
     pQueueCreateInfos = nullptr;
     enabledLayerCount = src.enabledLayerCount;
-    ppEnabledLayerNames = src.ppEnabledLayerNames;
     enabledExtensionCount = src.enabledExtensionCount;
-    ppEnabledExtensionNames = src.ppEnabledExtensionNames;
     pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(src.pNext);
+    char **tmp_ppEnabledLayerNames = new char *[src.enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(src.ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[src.enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(src.ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (queueCreateInfoCount && src.pQueueCreateInfos) {
         pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
-        for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
             pQueueCreateInfos[i].initialize(&src.pQueueCreateInfos[i]);
         }
     }
@@ -428,25 +558,47 @@ safe_VkDeviceCreateInfo::~safe_VkDeviceCreateInfo()
 {
     if (pQueueCreateInfos)
         delete[] pQueueCreateInfos;
+    if (ppEnabledLayerNames) {
+        for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+            delete [] ppEnabledLayerNames[i];
+        }
+        delete [] ppEnabledLayerNames;
+    }
+    if (ppEnabledExtensionNames) {
+        for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+            delete [] ppEnabledExtensionNames[i];
+        }
+        delete [] ppEnabledExtensionNames;
+    }
     if (pEnabledFeatures)
         delete pEnabledFeatures;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceCreateInfo::initialize(const VkDeviceCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     queueCreateInfoCount = in_struct->queueCreateInfoCount;
     pQueueCreateInfos = nullptr;
     enabledLayerCount = in_struct->enabledLayerCount;
-    ppEnabledLayerNames = in_struct->ppEnabledLayerNames;
     enabledExtensionCount = in_struct->enabledExtensionCount;
-    ppEnabledExtensionNames = in_struct->ppEnabledExtensionNames;
     pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
+    char **tmp_ppEnabledLayerNames = new char *[in_struct->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(in_struct->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[in_struct->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(in_struct->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (queueCreateInfoCount && in_struct->pQueueCreateInfos) {
         pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
-        for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
             pQueueCreateInfos[i].initialize(&in_struct->pQueueCreateInfos[i]);
         }
     }
@@ -458,18 +610,26 @@ void safe_VkDeviceCreateInfo::initialize(const VkDeviceCreateInfo* in_struct)
 void safe_VkDeviceCreateInfo::initialize(const safe_VkDeviceCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     queueCreateInfoCount = src->queueCreateInfoCount;
     pQueueCreateInfos = nullptr;
     enabledLayerCount = src->enabledLayerCount;
-    ppEnabledLayerNames = src->ppEnabledLayerNames;
     enabledExtensionCount = src->enabledExtensionCount;
-    ppEnabledExtensionNames = src->ppEnabledExtensionNames;
     pEnabledFeatures = nullptr;
+    pNext = SafePnextCopy(src->pNext);
+    char **tmp_ppEnabledLayerNames = new char *[src->enabledLayerCount];
+    for (uint32_t i = 0; i < enabledLayerCount; ++i) {
+        tmp_ppEnabledLayerNames[i] = SafeStringCopy(src->ppEnabledLayerNames[i]);
+    }
+    ppEnabledLayerNames = tmp_ppEnabledLayerNames;
+    char **tmp_ppEnabledExtensionNames = new char *[src->enabledExtensionCount];
+    for (uint32_t i = 0; i < enabledExtensionCount; ++i) {
+        tmp_ppEnabledExtensionNames[i] = SafeStringCopy(src->ppEnabledExtensionNames[i]);
+    }
+    ppEnabledExtensionNames = tmp_ppEnabledExtensionNames;
     if (queueCreateInfoCount && src->pQueueCreateInfos) {
         pQueueCreateInfos = new safe_VkDeviceQueueCreateInfo[queueCreateInfoCount];
-        for (uint32_t i=0; i<queueCreateInfoCount; ++i) {
+        for (uint32_t i = 0; i < queueCreateInfoCount; ++i) {
             pQueueCreateInfos[i].initialize(&src->pQueueCreateInfos[i]);
         }
     }
@@ -480,7 +640,6 @@ void safe_VkDeviceCreateInfo::initialize(const safe_VkDeviceCreateInfo* src)
 
 safe_VkSubmitInfo::safe_VkSubmitInfo(const VkSubmitInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     waitSemaphoreCount(in_struct->waitSemaphoreCount),
     pWaitSemaphores(nullptr),
     pWaitDstStageMask(nullptr),
@@ -489,9 +648,10 @@ safe_VkSubmitInfo::safe_VkSubmitInfo(const VkSubmitInfo* in_struct) :
     signalSemaphoreCount(in_struct->signalSemaphoreCount),
     pSignalSemaphores(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
         }
     }
@@ -505,13 +665,14 @@ safe_VkSubmitInfo::safe_VkSubmitInfo(const VkSubmitInfo* in_struct) :
     }
     if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
         }
     }
 }
 
 safe_VkSubmitInfo::safe_VkSubmitInfo() :
+    pNext(nullptr),
     pWaitSemaphores(nullptr),
     pWaitDstStageMask(nullptr),
     pCommandBuffers(nullptr),
@@ -521,7 +682,6 @@ safe_VkSubmitInfo::safe_VkSubmitInfo() :
 safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     pWaitDstStageMask = nullptr;
@@ -529,9 +689,10 @@ safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& src)
     pCommandBuffers = nullptr;
     signalSemaphoreCount = src.signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (waitSemaphoreCount && src.pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src.pWaitSemaphores[i];
         }
     }
@@ -545,7 +706,7 @@ safe_VkSubmitInfo::safe_VkSubmitInfo(const safe_VkSubmitInfo& src)
     }
     if (signalSemaphoreCount && src.pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = src.pSignalSemaphores[i];
         }
     }
@@ -563,9 +724,10 @@ safe_VkSubmitInfo& safe_VkSubmitInfo::operator=(const safe_VkSubmitInfo& src)
         delete[] pCommandBuffers;
     if (pSignalSemaphores)
         delete[] pSignalSemaphores;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     pWaitDstStageMask = nullptr;
@@ -573,9 +735,10 @@ safe_VkSubmitInfo& safe_VkSubmitInfo::operator=(const safe_VkSubmitInfo& src)
     pCommandBuffers = nullptr;
     signalSemaphoreCount = src.signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (waitSemaphoreCount && src.pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src.pWaitSemaphores[i];
         }
     }
@@ -589,7 +752,7 @@ safe_VkSubmitInfo& safe_VkSubmitInfo::operator=(const safe_VkSubmitInfo& src)
     }
     if (signalSemaphoreCount && src.pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = src.pSignalSemaphores[i];
         }
     }
@@ -607,12 +770,13 @@ safe_VkSubmitInfo::~safe_VkSubmitInfo()
         delete[] pCommandBuffers;
     if (pSignalSemaphores)
         delete[] pSignalSemaphores;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     waitSemaphoreCount = in_struct->waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     pWaitDstStageMask = nullptr;
@@ -620,9 +784,10 @@ void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct)
     pCommandBuffers = nullptr;
     signalSemaphoreCount = in_struct->signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
         }
     }
@@ -636,7 +801,7 @@ void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct)
     }
     if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
         }
     }
@@ -645,7 +810,6 @@ void safe_VkSubmitInfo::initialize(const VkSubmitInfo* in_struct)
 void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     waitSemaphoreCount = src->waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     pWaitDstStageMask = nullptr;
@@ -653,9 +817,10 @@ void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* src)
     pCommandBuffers = nullptr;
     signalSemaphoreCount = src->signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (waitSemaphoreCount && src->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src->pWaitSemaphores[i];
         }
     }
@@ -669,7 +834,7 @@ void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* src)
     }
     if (signalSemaphoreCount && src->pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = src->pSignalSemaphores[i];
         }
     }
@@ -677,111 +842,121 @@ void safe_VkSubmitInfo::initialize(const safe_VkSubmitInfo* src)
 
 safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const VkMemoryAllocateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     allocationSize(in_struct->allocationSize),
     memoryTypeIndex(in_struct->memoryTypeIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo()
+safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryAllocateInfo::safe_VkMemoryAllocateInfo(const safe_VkMemoryAllocateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     allocationSize = src.allocationSize;
     memoryTypeIndex = src.memoryTypeIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryAllocateInfo& safe_VkMemoryAllocateInfo::operator=(const safe_VkMemoryAllocateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     allocationSize = src.allocationSize;
     memoryTypeIndex = src.memoryTypeIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryAllocateInfo::~safe_VkMemoryAllocateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryAllocateInfo::initialize(const VkMemoryAllocateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     allocationSize = in_struct->allocationSize;
     memoryTypeIndex = in_struct->memoryTypeIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryAllocateInfo::initialize(const safe_VkMemoryAllocateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     allocationSize = src->allocationSize;
     memoryTypeIndex = src->memoryTypeIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const VkMappedMemoryRange* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memory(in_struct->memory),
     offset(in_struct->offset),
     size(in_struct->size)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMappedMemoryRange::safe_VkMappedMemoryRange()
+safe_VkMappedMemoryRange::safe_VkMappedMemoryRange() :
+    pNext(nullptr)
 {}
 
 safe_VkMappedMemoryRange::safe_VkMappedMemoryRange(const safe_VkMappedMemoryRange& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
     offset = src.offset;
     size = src.size;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMappedMemoryRange& safe_VkMappedMemoryRange::operator=(const safe_VkMappedMemoryRange& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
     offset = src.offset;
     size = src.size;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMappedMemoryRange::~safe_VkMappedMemoryRange()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMappedMemoryRange::initialize(const VkMappedMemoryRange* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memory = in_struct->memory;
     offset = in_struct->offset;
     size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMappedMemoryRange::initialize(const safe_VkMappedMemoryRange* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memory = src->memory;
     offset = src->offset;
     size = src->size;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSparseBufferMemoryBindInfo* in_struct) :
@@ -791,7 +966,7 @@ safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const VkSpa
 {
     if (bindCount && in_struct->pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
@@ -808,7 +983,7 @@ safe_VkSparseBufferMemoryBindInfo::safe_VkSparseBufferMemoryBindInfo(const safe_
     pBinds = nullptr;
     if (bindCount && src.pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src.pBinds[i];
         }
     }
@@ -826,7 +1001,7 @@ safe_VkSparseBufferMemoryBindInfo& safe_VkSparseBufferMemoryBindInfo::operator=(
     pBinds = nullptr;
     if (bindCount && src.pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src.pBinds[i];
         }
     }
@@ -847,7 +1022,7 @@ void safe_VkSparseBufferMemoryBindInfo::initialize(const VkSparseBufferMemoryBin
     pBinds = nullptr;
     if (bindCount && in_struct->pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
@@ -860,7 +1035,7 @@ void safe_VkSparseBufferMemoryBindInfo::initialize(const safe_VkSparseBufferMemo
     pBinds = nullptr;
     if (bindCount && src->pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src->pBinds[i];
         }
     }
@@ -873,7 +1048,7 @@ safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(c
 {
     if (bindCount && in_struct->pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
@@ -890,7 +1065,7 @@ safe_VkSparseImageOpaqueMemoryBindInfo::safe_VkSparseImageOpaqueMemoryBindInfo(c
     pBinds = nullptr;
     if (bindCount && src.pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src.pBinds[i];
         }
     }
@@ -908,7 +1083,7 @@ safe_VkSparseImageOpaqueMemoryBindInfo& safe_VkSparseImageOpaqueMemoryBindInfo::
     pBinds = nullptr;
     if (bindCount && src.pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src.pBinds[i];
         }
     }
@@ -929,7 +1104,7 @@ void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const VkSparseImageOpaqu
     pBinds = nullptr;
     if (bindCount && in_struct->pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
@@ -942,7 +1117,7 @@ void safe_VkSparseImageOpaqueMemoryBindInfo::initialize(const safe_VkSparseImage
     pBinds = nullptr;
     if (bindCount && src->pBinds) {
         pBinds = new VkSparseMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src->pBinds[i];
         }
     }
@@ -955,7 +1130,7 @@ safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const VkSpars
 {
     if (bindCount && in_struct->pBinds) {
         pBinds = new VkSparseImageMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
@@ -972,7 +1147,7 @@ safe_VkSparseImageMemoryBindInfo::safe_VkSparseImageMemoryBindInfo(const safe_Vk
     pBinds = nullptr;
     if (bindCount && src.pBinds) {
         pBinds = new VkSparseImageMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src.pBinds[i];
         }
     }
@@ -990,7 +1165,7 @@ safe_VkSparseImageMemoryBindInfo& safe_VkSparseImageMemoryBindInfo::operator=(co
     pBinds = nullptr;
     if (bindCount && src.pBinds) {
         pBinds = new VkSparseImageMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src.pBinds[i];
         }
     }
@@ -1011,7 +1186,7 @@ void safe_VkSparseImageMemoryBindInfo::initialize(const VkSparseImageMemoryBindI
     pBinds = nullptr;
     if (bindCount && in_struct->pBinds) {
         pBinds = new VkSparseImageMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = in_struct->pBinds[i];
         }
     }
@@ -1024,7 +1199,7 @@ void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemory
     pBinds = nullptr;
     if (bindCount && src->pBinds) {
         pBinds = new VkSparseImageMemoryBind[bindCount];
-        for (uint32_t i=0; i<bindCount; ++i) {
+        for (uint32_t i = 0; i < bindCount; ++i) {
             pBinds[i] = src->pBinds[i];
         }
     }
@@ -1032,7 +1207,6 @@ void safe_VkSparseImageMemoryBindInfo::initialize(const safe_VkSparseImageMemory
 
 safe_VkBindSparseInfo::safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     waitSemaphoreCount(in_struct->waitSemaphoreCount),
     pWaitSemaphores(nullptr),
     bufferBindCount(in_struct->bufferBindCount),
@@ -1044,39 +1218,41 @@ safe_VkBindSparseInfo::safe_VkBindSparseInfo(const VkBindSparseInfo* in_struct)
     signalSemaphoreCount(in_struct->signalSemaphoreCount),
     pSignalSemaphores(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
         }
     }
     if (bufferBindCount && in_struct->pBufferBinds) {
         pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
-        for (uint32_t i=0; i<bufferBindCount; ++i) {
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
             pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
         }
     }
     if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
         pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
-        for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
             pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
         }
     }
     if (imageBindCount && in_struct->pImageBinds) {
         pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
-        for (uint32_t i=0; i<imageBindCount; ++i) {
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
             pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
         }
     }
     if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
         }
     }
 }
 
 safe_VkBindSparseInfo::safe_VkBindSparseInfo() :
+    pNext(nullptr),
     pWaitSemaphores(nullptr),
     pBufferBinds(nullptr),
     pImageOpaqueBinds(nullptr),
@@ -1087,7 +1263,6 @@ safe_VkBindSparseInfo::safe_VkBindSparseInfo() :
 safe_VkBindSparseInfo::safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     bufferBindCount = src.bufferBindCount;
@@ -1098,33 +1273,34 @@ safe_VkBindSparseInfo::safe_VkBindSparseInfo(const safe_VkBindSparseInfo& src)
     pImageBinds = nullptr;
     signalSemaphoreCount = src.signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (waitSemaphoreCount && src.pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src.pWaitSemaphores[i];
         }
     }
     if (bufferBindCount && src.pBufferBinds) {
         pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
-        for (uint32_t i=0; i<bufferBindCount; ++i) {
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
             pBufferBinds[i].initialize(&src.pBufferBinds[i]);
         }
     }
     if (imageOpaqueBindCount && src.pImageOpaqueBinds) {
         pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
-        for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
             pImageOpaqueBinds[i].initialize(&src.pImageOpaqueBinds[i]);
         }
     }
     if (imageBindCount && src.pImageBinds) {
         pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
-        for (uint32_t i=0; i<imageBindCount; ++i) {
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
             pImageBinds[i].initialize(&src.pImageBinds[i]);
         }
     }
     if (signalSemaphoreCount && src.pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = src.pSignalSemaphores[i];
         }
     }
@@ -1144,9 +1320,10 @@ safe_VkBindSparseInfo& safe_VkBindSparseInfo::operator=(const safe_VkBindSparseI
         delete[] pImageBinds;
     if (pSignalSemaphores)
         delete[] pSignalSemaphores;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     bufferBindCount = src.bufferBindCount;
@@ -1157,33 +1334,34 @@ safe_VkBindSparseInfo& safe_VkBindSparseInfo::operator=(const safe_VkBindSparseI
     pImageBinds = nullptr;
     signalSemaphoreCount = src.signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (waitSemaphoreCount && src.pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src.pWaitSemaphores[i];
         }
     }
     if (bufferBindCount && src.pBufferBinds) {
         pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
-        for (uint32_t i=0; i<bufferBindCount; ++i) {
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
             pBufferBinds[i].initialize(&src.pBufferBinds[i]);
         }
     }
     if (imageOpaqueBindCount && src.pImageOpaqueBinds) {
         pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
-        for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
             pImageOpaqueBinds[i].initialize(&src.pImageOpaqueBinds[i]);
         }
     }
     if (imageBindCount && src.pImageBinds) {
         pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
-        for (uint32_t i=0; i<imageBindCount; ++i) {
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
             pImageBinds[i].initialize(&src.pImageBinds[i]);
         }
     }
     if (signalSemaphoreCount && src.pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = src.pSignalSemaphores[i];
         }
     }
@@ -1203,12 +1381,13 @@ safe_VkBindSparseInfo::~safe_VkBindSparseInfo()
         delete[] pImageBinds;
     if (pSignalSemaphores)
         delete[] pSignalSemaphores;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindSparseInfo::initialize(const VkBindSparseInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     waitSemaphoreCount = in_struct->waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     bufferBindCount = in_struct->bufferBindCount;
@@ -1219,33 +1398,34 @@ void safe_VkBindSparseInfo::initialize(const VkBindSparseInfo* in_struct)
     pImageBinds = nullptr;
     signalSemaphoreCount = in_struct->signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
         }
     }
     if (bufferBindCount && in_struct->pBufferBinds) {
         pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
-        for (uint32_t i=0; i<bufferBindCount; ++i) {
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
             pBufferBinds[i].initialize(&in_struct->pBufferBinds[i]);
         }
     }
     if (imageOpaqueBindCount && in_struct->pImageOpaqueBinds) {
         pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
-        for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
             pImageOpaqueBinds[i].initialize(&in_struct->pImageOpaqueBinds[i]);
         }
     }
     if (imageBindCount && in_struct->pImageBinds) {
         pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
-        for (uint32_t i=0; i<imageBindCount; ++i) {
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
             pImageBinds[i].initialize(&in_struct->pImageBinds[i]);
         }
     }
     if (signalSemaphoreCount && in_struct->pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = in_struct->pSignalSemaphores[i];
         }
     }
@@ -1254,7 +1434,6 @@ void safe_VkBindSparseInfo::initialize(const VkBindSparseInfo* in_struct)
 void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     waitSemaphoreCount = src->waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     bufferBindCount = src->bufferBindCount;
@@ -1265,33 +1444,34 @@ void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* src)
     pImageBinds = nullptr;
     signalSemaphoreCount = src->signalSemaphoreCount;
     pSignalSemaphores = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (waitSemaphoreCount && src->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src->pWaitSemaphores[i];
         }
     }
     if (bufferBindCount && src->pBufferBinds) {
         pBufferBinds = new safe_VkSparseBufferMemoryBindInfo[bufferBindCount];
-        for (uint32_t i=0; i<bufferBindCount; ++i) {
+        for (uint32_t i = 0; i < bufferBindCount; ++i) {
             pBufferBinds[i].initialize(&src->pBufferBinds[i]);
         }
     }
     if (imageOpaqueBindCount && src->pImageOpaqueBinds) {
         pImageOpaqueBinds = new safe_VkSparseImageOpaqueMemoryBindInfo[imageOpaqueBindCount];
-        for (uint32_t i=0; i<imageOpaqueBindCount; ++i) {
+        for (uint32_t i = 0; i < imageOpaqueBindCount; ++i) {
             pImageOpaqueBinds[i].initialize(&src->pImageOpaqueBinds[i]);
         }
     }
     if (imageBindCount && src->pImageBinds) {
         pImageBinds = new safe_VkSparseImageMemoryBindInfo[imageBindCount];
-        for (uint32_t i=0; i<imageBindCount; ++i) {
+        for (uint32_t i = 0; i < imageBindCount; ++i) {
             pImageBinds[i].initialize(&src->pImageBinds[i]);
         }
     }
     if (signalSemaphoreCount && src->pSignalSemaphores) {
         pSignalSemaphores = new VkSemaphore[signalSemaphoreCount];
-        for (uint32_t i=0; i<signalSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < signalSemaphoreCount; ++i) {
             pSignalSemaphores[i] = src->pSignalSemaphores[i];
         }
     }
@@ -1299,210 +1479,229 @@ void safe_VkBindSparseInfo::initialize(const safe_VkBindSparseInfo* src)
 
 safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const VkFenceCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkFenceCreateInfo::safe_VkFenceCreateInfo()
+safe_VkFenceCreateInfo::safe_VkFenceCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkFenceCreateInfo::safe_VkFenceCreateInfo(const safe_VkFenceCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkFenceCreateInfo& safe_VkFenceCreateInfo::operator=(const safe_VkFenceCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkFenceCreateInfo::~safe_VkFenceCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFenceCreateInfo::initialize(const VkFenceCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkFenceCreateInfo::initialize(const safe_VkFenceCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo()
+safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkSemaphoreCreateInfo::safe_VkSemaphoreCreateInfo(const safe_VkSemaphoreCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSemaphoreCreateInfo& safe_VkSemaphoreCreateInfo::operator=(const safe_VkSemaphoreCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSemaphoreCreateInfo::~safe_VkSemaphoreCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSemaphoreCreateInfo::initialize(const VkSemaphoreCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSemaphoreCreateInfo::initialize(const safe_VkSemaphoreCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkEventCreateInfo::safe_VkEventCreateInfo(const VkEventCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkEventCreateInfo::safe_VkEventCreateInfo()
+safe_VkEventCreateInfo::safe_VkEventCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkEventCreateInfo::safe_VkEventCreateInfo(const safe_VkEventCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkEventCreateInfo& safe_VkEventCreateInfo::operator=(const safe_VkEventCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkEventCreateInfo::~safe_VkEventCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkEventCreateInfo::initialize(const VkEventCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkEventCreateInfo::initialize(const safe_VkEventCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     queryType(in_struct->queryType),
     queryCount(in_struct->queryCount),
     pipelineStatistics(in_struct->pipelineStatistics)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo()
+safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkQueryPoolCreateInfo::safe_VkQueryPoolCreateInfo(const safe_VkQueryPoolCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queryType = src.queryType;
     queryCount = src.queryCount;
     pipelineStatistics = src.pipelineStatistics;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkQueryPoolCreateInfo& safe_VkQueryPoolCreateInfo::operator=(const safe_VkQueryPoolCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queryType = src.queryType;
     queryCount = src.queryCount;
     pipelineStatistics = src.pipelineStatistics;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkQueryPoolCreateInfo::~safe_VkQueryPoolCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkQueryPoolCreateInfo::initialize(const VkQueryPoolCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     queryType = in_struct->queryType;
     queryCount = in_struct->queryCount;
     pipelineStatistics = in_struct->pipelineStatistics;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkQueryPoolCreateInfo::initialize(const safe_VkQueryPoolCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     queryType = src->queryType;
     queryCount = src->queryCount;
     pipelineStatistics = src->pipelineStatistics;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     size(in_struct->size),
     usage(in_struct->usage),
@@ -1510,6 +1709,7 @@ safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_st
     queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
     pQueueFamilyIndices(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -1517,19 +1717,20 @@ safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const VkBufferCreateInfo* in_st
 }
 
 safe_VkBufferCreateInfo::safe_VkBufferCreateInfo() :
+    pNext(nullptr),
     pQueueFamilyIndices(nullptr)
 {}
 
 safe_VkBufferCreateInfo::safe_VkBufferCreateInfo(const safe_VkBufferCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     size = src.size;
     usage = src.usage;
     sharingMode = src.sharingMode;
     queueFamilyIndexCount = src.queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -1542,15 +1743,17 @@ safe_VkBufferCreateInfo& safe_VkBufferCreateInfo::operator=(const safe_VkBufferC
 
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     size = src.size;
     usage = src.usage;
     sharingMode = src.sharingMode;
     queueFamilyIndexCount = src.queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -1563,18 +1766,20 @@ safe_VkBufferCreateInfo::~safe_VkBufferCreateInfo()
 {
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBufferCreateInfo::initialize(const VkBufferCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     size = in_struct->size;
     usage = in_struct->usage;
     sharingMode = in_struct->sharingMode;
     queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -1584,13 +1789,13 @@ void safe_VkBufferCreateInfo::initialize(const VkBufferCreateInfo* in_struct)
 void safe_VkBufferCreateInfo::initialize(const safe_VkBufferCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     size = src->size;
     usage = src->usage;
     sharingMode = src->sharingMode;
     queueFamilyIndexCount = src->queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
@@ -1599,74 +1804,78 @@ void safe_VkBufferCreateInfo::initialize(const safe_VkBufferCreateInfo* src)
 
 safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const VkBufferViewCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     buffer(in_struct->buffer),
     format(in_struct->format),
     offset(in_struct->offset),
     range(in_struct->range)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo()
+safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkBufferViewCreateInfo::safe_VkBufferViewCreateInfo(const safe_VkBufferViewCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     buffer = src.buffer;
     format = src.format;
     offset = src.offset;
     range = src.range;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBufferViewCreateInfo& safe_VkBufferViewCreateInfo::operator=(const safe_VkBufferViewCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     buffer = src.buffer;
     format = src.format;
     offset = src.offset;
     range = src.range;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBufferViewCreateInfo::~safe_VkBufferViewCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBufferViewCreateInfo::initialize(const VkBufferViewCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     buffer = in_struct->buffer;
     format = in_struct->format;
     offset = in_struct->offset;
     range = in_struct->range;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBufferViewCreateInfo::initialize(const safe_VkBufferViewCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     buffer = src->buffer;
     format = src->format;
     offset = src->offset;
     range = src->range;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageCreateInfo::safe_VkImageCreateInfo(const VkImageCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     imageType(in_struct->imageType),
     format(in_struct->format),
@@ -1681,6 +1890,7 @@ safe_VkImageCreateInfo::safe_VkImageCreateInfo(const VkImageCreateInfo* in_struc
     pQueueFamilyIndices(nullptr),
     initialLayout(in_struct->initialLayout)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -1688,13 +1898,13 @@ safe_VkImageCreateInfo::safe_VkImageCreateInfo(const VkImageCreateInfo* in_struc
 }
 
 safe_VkImageCreateInfo::safe_VkImageCreateInfo() :
+    pNext(nullptr),
     pQueueFamilyIndices(nullptr)
 {}
 
 safe_VkImageCreateInfo::safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     imageType = src.imageType;
     format = src.format;
@@ -1708,6 +1918,7 @@ safe_VkImageCreateInfo::safe_VkImageCreateInfo(const safe_VkImageCreateInfo& src
     queueFamilyIndexCount = src.queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
     initialLayout = src.initialLayout;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -1720,9 +1931,10 @@ safe_VkImageCreateInfo& safe_VkImageCreateInfo::operator=(const safe_VkImageCrea
 
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     imageType = src.imageType;
     format = src.format;
@@ -1736,6 +1948,7 @@ safe_VkImageCreateInfo& safe_VkImageCreateInfo::operator=(const safe_VkImageCrea
     queueFamilyIndexCount = src.queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
     initialLayout = src.initialLayout;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -1748,12 +1961,13 @@ safe_VkImageCreateInfo::~safe_VkImageCreateInfo()
 {
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageCreateInfo::initialize(const VkImageCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     imageType = in_struct->imageType;
     format = in_struct->format;
@@ -1767,6 +1981,7 @@ void safe_VkImageCreateInfo::initialize(const VkImageCreateInfo* in_struct)
     queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
     initialLayout = in_struct->initialLayout;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -1776,7 +1991,6 @@ void safe_VkImageCreateInfo::initialize(const VkImageCreateInfo* in_struct)
 void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     imageType = src->imageType;
     format = src->format;
@@ -1790,6 +2004,7 @@ void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* src)
     queueFamilyIndexCount = src->queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
     initialLayout = src->initialLayout;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
@@ -1798,7 +2013,6 @@ void safe_VkImageCreateInfo::initialize(const safe_VkImageCreateInfo* src)
 
 safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const VkImageViewCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     image(in_struct->image),
     viewType(in_struct->viewType),
@@ -1806,75 +2020,81 @@ safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const VkImageViewCreateIn
     components(in_struct->components),
     subresourceRange(in_struct->subresourceRange)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo()
+safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkImageViewCreateInfo::safe_VkImageViewCreateInfo(const safe_VkImageViewCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     image = src.image;
     viewType = src.viewType;
     format = src.format;
     components = src.components;
     subresourceRange = src.subresourceRange;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageViewCreateInfo& safe_VkImageViewCreateInfo::operator=(const safe_VkImageViewCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     image = src.image;
     viewType = src.viewType;
     format = src.format;
     components = src.components;
     subresourceRange = src.subresourceRange;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageViewCreateInfo::~safe_VkImageViewCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageViewCreateInfo::initialize(const VkImageViewCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     image = in_struct->image;
     viewType = in_struct->viewType;
     format = in_struct->format;
     components = in_struct->components;
     subresourceRange = in_struct->subresourceRange;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageViewCreateInfo::initialize(const safe_VkImageViewCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     image = src->image;
     viewType = src->viewType;
     format = src->format;
     components = src->components;
     subresourceRange = src->subresourceRange;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     codeSize(in_struct->codeSize),
     pCode(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pCode) {
         pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
         memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);
@@ -1882,16 +2102,17 @@ safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const VkShaderModul
 }
 
 safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo() :
+    pNext(nullptr),
     pCode(nullptr)
 {}
 
 safe_VkShaderModuleCreateInfo::safe_VkShaderModuleCreateInfo(const safe_VkShaderModuleCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     codeSize = src.codeSize;
     pCode = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pCode) {
         pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
         memcpy((void *)pCode, (void *)src.pCode, codeSize);
@@ -1904,12 +2125,14 @@ safe_VkShaderModuleCreateInfo& safe_VkShaderModuleCreateInfo::operator=(const sa
 
     if (pCode)
         delete[] reinterpret_cast<const uint8_t *>(pCode);
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     codeSize = src.codeSize;
     pCode = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pCode) {
         pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
         memcpy((void *)pCode, (void *)src.pCode, codeSize);
@@ -1922,15 +2145,17 @@ safe_VkShaderModuleCreateInfo::~safe_VkShaderModuleCreateInfo()
 {
     if (pCode)
         delete[] reinterpret_cast<const uint8_t *>(pCode);
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkShaderModuleCreateInfo::initialize(const VkShaderModuleCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     codeSize = in_struct->codeSize;
     pCode = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pCode) {
         pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
         memcpy((void *)pCode, (void *)in_struct->pCode, codeSize);
@@ -1940,10 +2165,10 @@ void safe_VkShaderModuleCreateInfo::initialize(const VkShaderModuleCreateInfo* i
 void safe_VkShaderModuleCreateInfo::initialize(const safe_VkShaderModuleCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     codeSize = src->codeSize;
     pCode = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pCode) {
         pCode = reinterpret_cast<uint32_t *>(new uint8_t[codeSize]);
         memcpy((void *)pCode, (void *)src->pCode, codeSize);
@@ -1952,59 +2177,65 @@ void safe_VkShaderModuleCreateInfo::initialize(const safe_VkShaderModuleCreateIn
 
 safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     initialDataSize(in_struct->initialDataSize),
     pInitialData(in_struct->pInitialData)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo()
+safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo() :
+    pNext(nullptr),
+    pInitialData(nullptr)
 {}
 
 safe_VkPipelineCacheCreateInfo::safe_VkPipelineCacheCreateInfo(const safe_VkPipelineCacheCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     initialDataSize = src.initialDataSize;
     pInitialData = src.pInitialData;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineCacheCreateInfo& safe_VkPipelineCacheCreateInfo::operator=(const safe_VkPipelineCacheCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     initialDataSize = src.initialDataSize;
     pInitialData = src.pInitialData;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineCacheCreateInfo::~safe_VkPipelineCacheCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineCacheCreateInfo::initialize(const VkPipelineCacheCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     initialDataSize = in_struct->initialDataSize;
     pInitialData = in_struct->pInitialData;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineCacheCreateInfo::initialize(const safe_VkPipelineCacheCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     initialDataSize = src->initialDataSize;
     pInitialData = src->pInitialData;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSpecializationInfo::safe_VkSpecializationInfo(const VkSpecializationInfo* in_struct) :
@@ -2020,7 +2251,8 @@ safe_VkSpecializationInfo::safe_VkSpecializationInfo(const VkSpecializationInfo*
 }
 
 safe_VkSpecializationInfo::safe_VkSpecializationInfo() :
-    pMapEntries(nullptr)
+    pMapEntries(nullptr),
+    pData(nullptr)
 {}
 
 safe_VkSpecializationInfo::safe_VkSpecializationInfo(const safe_VkSpecializationInfo& src)
@@ -2086,99 +2318,103 @@ void safe_VkSpecializationInfo::initialize(const safe_VkSpecializationInfo* src)
 
 safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const VkPipelineShaderStageCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     stage(in_struct->stage),
     module(in_struct->module),
-    pName(in_struct->pName)
+    pSpecializationInfo(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pName = SafeStringCopy(in_struct->pName);
     if (in_struct->pSpecializationInfo)
         pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
-    else
-        pSpecializationInfo = NULL;
 }
 
-safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo()
+safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo() :
+    pNext(nullptr),
+    pName(nullptr),
+    pSpecializationInfo(nullptr)
 {}
 
 safe_VkPipelineShaderStageCreateInfo::safe_VkPipelineShaderStageCreateInfo(const safe_VkPipelineShaderStageCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stage = src.stage;
     module = src.module;
-    pName = src.pName;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(src.pNext);
+    pName = SafeStringCopy(src.pName);
     if (src.pSpecializationInfo)
         pSpecializationInfo = new safe_VkSpecializationInfo(*src.pSpecializationInfo);
-    else
-        pSpecializationInfo = NULL;
 }
 
 safe_VkPipelineShaderStageCreateInfo& safe_VkPipelineShaderStageCreateInfo::operator=(const safe_VkPipelineShaderStageCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pName) delete [] pName;
     if (pSpecializationInfo)
         delete pSpecializationInfo;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stage = src.stage;
     module = src.module;
-    pName = src.pName;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(src.pNext);
+    pName = SafeStringCopy(src.pName);
     if (src.pSpecializationInfo)
         pSpecializationInfo = new safe_VkSpecializationInfo(*src.pSpecializationInfo);
-    else
-        pSpecializationInfo = NULL;
 
     return *this;
 }
 
 safe_VkPipelineShaderStageCreateInfo::~safe_VkPipelineShaderStageCreateInfo()
 {
+    if (pName) delete [] pName;
     if (pSpecializationInfo)
         delete pSpecializationInfo;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineShaderStageCreateInfo::initialize(const VkPipelineShaderStageCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     stage = in_struct->stage;
     module = in_struct->module;
-    pName = in_struct->pName;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
+    pName = SafeStringCopy(in_struct->pName);
     if (in_struct->pSpecializationInfo)
         pSpecializationInfo = new safe_VkSpecializationInfo(in_struct->pSpecializationInfo);
-    else
-        pSpecializationInfo = NULL;
 }
 
 void safe_VkPipelineShaderStageCreateInfo::initialize(const safe_VkPipelineShaderStageCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     stage = src->stage;
     module = src->module;
-    pName = src->pName;
+    pSpecializationInfo = nullptr;
+    pNext = SafePnextCopy(src->pNext);
+    pName = SafeStringCopy(src->pName);
     if (src->pSpecializationInfo)
         pSpecializationInfo = new safe_VkSpecializationInfo(*src->pSpecializationInfo);
-    else
-        pSpecializationInfo = NULL;
 }
 
 safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(const VkPipelineVertexInputStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     vertexBindingDescriptionCount(in_struct->vertexBindingDescriptionCount),
     pVertexBindingDescriptions(nullptr),
     vertexAttributeDescriptionCount(in_struct->vertexAttributeDescriptionCount),
     pVertexAttributeDescriptions(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pVertexBindingDescriptions) {
         pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
         memcpy ((void *)pVertexBindingDescriptions, (void *)in_struct->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*in_struct->vertexBindingDescriptionCount);
@@ -2190,6 +2426,7 @@ safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreate
 }
 
 safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo() :
+    pNext(nullptr),
     pVertexBindingDescriptions(nullptr),
     pVertexAttributeDescriptions(nullptr)
 {}
@@ -2197,12 +2434,12 @@ safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreate
 safe_VkPipelineVertexInputStateCreateInfo::safe_VkPipelineVertexInputStateCreateInfo(const safe_VkPipelineVertexInputStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     vertexBindingDescriptionCount = src.vertexBindingDescriptionCount;
     pVertexBindingDescriptions = nullptr;
     vertexAttributeDescriptionCount = src.vertexAttributeDescriptionCount;
     pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pVertexBindingDescriptions) {
         pVertexBindingDescriptions = new VkVertexInputBindingDescription[src.vertexBindingDescriptionCount];
         memcpy ((void *)pVertexBindingDescriptions, (void *)src.pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*src.vertexBindingDescriptionCount);
@@ -2221,14 +2458,16 @@ safe_VkPipelineVertexInputStateCreateInfo& safe_VkPipelineVertexInputStateCreate
         delete[] pVertexBindingDescriptions;
     if (pVertexAttributeDescriptions)
         delete[] pVertexAttributeDescriptions;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     vertexBindingDescriptionCount = src.vertexBindingDescriptionCount;
     pVertexBindingDescriptions = nullptr;
     vertexAttributeDescriptionCount = src.vertexAttributeDescriptionCount;
     pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pVertexBindingDescriptions) {
         pVertexBindingDescriptions = new VkVertexInputBindingDescription[src.vertexBindingDescriptionCount];
         memcpy ((void *)pVertexBindingDescriptions, (void *)src.pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*src.vertexBindingDescriptionCount);
@@ -2247,17 +2486,19 @@ safe_VkPipelineVertexInputStateCreateInfo::~safe_VkPipelineVertexInputStateCreat
         delete[] pVertexBindingDescriptions;
     if (pVertexAttributeDescriptions)
         delete[] pVertexAttributeDescriptions;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVertexInputStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     vertexBindingDescriptionCount = in_struct->vertexBindingDescriptionCount;
     pVertexBindingDescriptions = nullptr;
     vertexAttributeDescriptionCount = in_struct->vertexAttributeDescriptionCount;
     pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pVertexBindingDescriptions) {
         pVertexBindingDescriptions = new VkVertexInputBindingDescription[in_struct->vertexBindingDescriptionCount];
         memcpy ((void *)pVertexBindingDescriptions, (void *)in_struct->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*in_struct->vertexBindingDescriptionCount);
@@ -2271,12 +2512,12 @@ void safe_VkPipelineVertexInputStateCreateInfo::initialize(const VkPipelineVerte
 void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipelineVertexInputStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     vertexBindingDescriptionCount = src->vertexBindingDescriptionCount;
     pVertexBindingDescriptions = nullptr;
     vertexAttributeDescriptionCount = src->vertexAttributeDescriptionCount;
     pVertexAttributeDescriptions = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pVertexBindingDescriptions) {
         pVertexBindingDescriptions = new VkVertexInputBindingDescription[src->vertexBindingDescriptionCount];
         memcpy ((void *)pVertexBindingDescriptions, (void *)src->pVertexBindingDescriptions, sizeof(VkVertexInputBindingDescription)*src->vertexBindingDescriptionCount);
@@ -2289,122 +2530,132 @@ void safe_VkPipelineVertexInputStateCreateInfo::initialize(const safe_VkPipeline
 
 safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(const VkPipelineInputAssemblyStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     topology(in_struct->topology),
     primitiveRestartEnable(in_struct->primitiveRestartEnable)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo()
+safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineInputAssemblyStateCreateInfo::safe_VkPipelineInputAssemblyStateCreateInfo(const safe_VkPipelineInputAssemblyStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     topology = src.topology;
     primitiveRestartEnable = src.primitiveRestartEnable;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineInputAssemblyStateCreateInfo& safe_VkPipelineInputAssemblyStateCreateInfo::operator=(const safe_VkPipelineInputAssemblyStateCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     topology = src.topology;
     primitiveRestartEnable = src.primitiveRestartEnable;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineInputAssemblyStateCreateInfo::~safe_VkPipelineInputAssemblyStateCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const VkPipelineInputAssemblyStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     topology = in_struct->topology;
     primitiveRestartEnable = in_struct->primitiveRestartEnable;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineInputAssemblyStateCreateInfo::initialize(const safe_VkPipelineInputAssemblyStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     topology = src->topology;
     primitiveRestartEnable = src->primitiveRestartEnable;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(const VkPipelineTessellationStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     patchControlPoints(in_struct->patchControlPoints)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo()
+safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineTessellationStateCreateInfo::safe_VkPipelineTessellationStateCreateInfo(const safe_VkPipelineTessellationStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     patchControlPoints = src.patchControlPoints;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineTessellationStateCreateInfo& safe_VkPipelineTessellationStateCreateInfo::operator=(const safe_VkPipelineTessellationStateCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     patchControlPoints = src.patchControlPoints;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineTessellationStateCreateInfo::~safe_VkPipelineTessellationStateCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineTessellationStateCreateInfo::initialize(const VkPipelineTessellationStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     patchControlPoints = in_struct->patchControlPoints;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineTessellationStateCreateInfo::initialize(const safe_VkPipelineTessellationStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     patchControlPoints = src->patchControlPoints;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     viewportCount(in_struct->viewportCount),
     pViewports(nullptr),
     scissorCount(in_struct->scissorCount),
     pScissors(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewports && !is_dynamic_viewports) {
         pViewports = new VkViewport[in_struct->viewportCount];
         memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);
@@ -2420,6 +2671,7 @@ safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(c
 }
 
 safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo() :
+    pNext(nullptr),
     pViewports(nullptr),
     pScissors(nullptr)
 {}
@@ -2427,12 +2679,12 @@ safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo()
 safe_VkPipelineViewportStateCreateInfo::safe_VkPipelineViewportStateCreateInfo(const safe_VkPipelineViewportStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     viewportCount = src.viewportCount;
     pViewports = nullptr;
     scissorCount = src.scissorCount;
     pScissors = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewports) {
         pViewports = new VkViewport[src.viewportCount];
         memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);
@@ -2455,14 +2707,16 @@ safe_VkPipelineViewportStateCreateInfo& safe_VkPipelineViewportStateCreateInfo::
         delete[] pViewports;
     if (pScissors)
         delete[] pScissors;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     viewportCount = src.viewportCount;
     pViewports = nullptr;
     scissorCount = src.scissorCount;
     pScissors = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewports) {
         pViewports = new VkViewport[src.viewportCount];
         memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);
@@ -2485,17 +2739,19 @@ safe_VkPipelineViewportStateCreateInfo::~safe_VkPipelineViewportStateCreateInfo(
         delete[] pViewports;
     if (pScissors)
         delete[] pScissors;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineViewportStateCreateInfo::initialize(const VkPipelineViewportStateCreateInfo* in_struct, const bool is_dynamic_viewports, const bool is_dynamic_scissors)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     viewportCount = in_struct->viewportCount;
     pViewports = nullptr;
     scissorCount = in_struct->scissorCount;
     pScissors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewports && !is_dynamic_viewports) {
         pViewports = new VkViewport[in_struct->viewportCount];
         memcpy ((void *)pViewports, (void *)in_struct->pViewports, sizeof(VkViewport)*in_struct->viewportCount);
@@ -2513,12 +2769,12 @@ void safe_VkPipelineViewportStateCreateInfo::initialize(const VkPipelineViewport
 void safe_VkPipelineViewportStateCreateInfo::initialize(const safe_VkPipelineViewportStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     viewportCount = src->viewportCount;
     pViewports = nullptr;
     scissorCount = src->scissorCount;
     pScissors = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pViewports) {
         pViewports = new VkViewport[src->viewportCount];
         memcpy ((void *)pViewports, (void *)src->pViewports, sizeof(VkViewport)*src->viewportCount);
@@ -2535,7 +2791,6 @@ void safe_VkPipelineViewportStateCreateInfo::initialize(const safe_VkPipelineVie
 
 safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(const VkPipelineRasterizationStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     depthClampEnable(in_struct->depthClampEnable),
     rasterizerDiscardEnable(in_struct->rasterizerDiscardEnable),
@@ -2548,15 +2803,16 @@ safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCr
     depthBiasSlopeFactor(in_struct->depthBiasSlopeFactor),
     lineWidth(in_struct->lineWidth)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo()
+safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCreateInfo(const safe_VkPipelineRasterizationStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     depthClampEnable = src.depthClampEnable;
     rasterizerDiscardEnable = src.rasterizerDiscardEnable;
@@ -2568,15 +2824,17 @@ safe_VkPipelineRasterizationStateCreateInfo::safe_VkPipelineRasterizationStateCr
     depthBiasClamp = src.depthBiasClamp;
     depthBiasSlopeFactor = src.depthBiasSlopeFactor;
     lineWidth = src.lineWidth;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineRasterizationStateCreateInfo& safe_VkPipelineRasterizationStateCreateInfo::operator=(const safe_VkPipelineRasterizationStateCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     depthClampEnable = src.depthClampEnable;
     rasterizerDiscardEnable = src.rasterizerDiscardEnable;
@@ -2588,18 +2846,20 @@ safe_VkPipelineRasterizationStateCreateInfo& safe_VkPipelineRasterizationStateCr
     depthBiasClamp = src.depthBiasClamp;
     depthBiasSlopeFactor = src.depthBiasSlopeFactor;
     lineWidth = src.lineWidth;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineRasterizationStateCreateInfo::~safe_VkPipelineRasterizationStateCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRasterizationStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     depthClampEnable = in_struct->depthClampEnable;
     rasterizerDiscardEnable = in_struct->rasterizerDiscardEnable;
@@ -2611,12 +2871,12 @@ void safe_VkPipelineRasterizationStateCreateInfo::initialize(const VkPipelineRas
     depthBiasClamp = in_struct->depthBiasClamp;
     depthBiasSlopeFactor = in_struct->depthBiasSlopeFactor;
     lineWidth = in_struct->lineWidth;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipelineRasterizationStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     depthClampEnable = src->depthClampEnable;
     rasterizerDiscardEnable = src->rasterizerDiscardEnable;
@@ -2628,11 +2888,11 @@ void safe_VkPipelineRasterizationStateCreateInfo::initialize(const safe_VkPipeli
     depthBiasClamp = src->depthBiasClamp;
     depthBiasSlopeFactor = src->depthBiasSlopeFactor;
     lineWidth = src->lineWidth;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     rasterizationSamples(in_struct->rasterizationSamples),
     sampleShadingEnable(in_struct->sampleShadingEnable),
@@ -2641,19 +2901,20 @@ safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreate
     alphaToCoverageEnable(in_struct->alphaToCoverageEnable),
     alphaToOneEnable(in_struct->alphaToOneEnable)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pSampleMask) {
         pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
     }
 }
 
 safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo() :
+    pNext(nullptr),
     pSampleMask(nullptr)
 {}
 
 safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreateInfo(const safe_VkPipelineMultisampleStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     rasterizationSamples = src.rasterizationSamples;
     sampleShadingEnable = src.sampleShadingEnable;
@@ -2661,6 +2922,7 @@ safe_VkPipelineMultisampleStateCreateInfo::safe_VkPipelineMultisampleStateCreate
     pSampleMask = nullptr;
     alphaToCoverageEnable = src.alphaToCoverageEnable;
     alphaToOneEnable = src.alphaToOneEnable;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pSampleMask) {
         pSampleMask = new VkSampleMask(*src.pSampleMask);
     }
@@ -2672,9 +2934,10 @@ safe_VkPipelineMultisampleStateCreateInfo& safe_VkPipelineMultisampleStateCreate
 
     if (pSampleMask)
         delete pSampleMask;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     rasterizationSamples = src.rasterizationSamples;
     sampleShadingEnable = src.sampleShadingEnable;
@@ -2682,6 +2945,7 @@ safe_VkPipelineMultisampleStateCreateInfo& safe_VkPipelineMultisampleStateCreate
     pSampleMask = nullptr;
     alphaToCoverageEnable = src.alphaToCoverageEnable;
     alphaToOneEnable = src.alphaToOneEnable;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pSampleMask) {
         pSampleMask = new VkSampleMask(*src.pSampleMask);
     }
@@ -2693,12 +2957,13 @@ safe_VkPipelineMultisampleStateCreateInfo::~safe_VkPipelineMultisampleStateCreat
 {
     if (pSampleMask)
         delete pSampleMask;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineMultisampleStateCreateInfo::initialize(const VkPipelineMultisampleStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     rasterizationSamples = in_struct->rasterizationSamples;
     sampleShadingEnable = in_struct->sampleShadingEnable;
@@ -2706,6 +2971,7 @@ void safe_VkPipelineMultisampleStateCreateInfo::initialize(const VkPipelineMulti
     pSampleMask = nullptr;
     alphaToCoverageEnable = in_struct->alphaToCoverageEnable;
     alphaToOneEnable = in_struct->alphaToOneEnable;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pSampleMask) {
         pSampleMask = new VkSampleMask(*in_struct->pSampleMask);
     }
@@ -2714,7 +2980,6 @@ void safe_VkPipelineMultisampleStateCreateInfo::initialize(const VkPipelineMulti
 void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipelineMultisampleStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     rasterizationSamples = src->rasterizationSamples;
     sampleShadingEnable = src->sampleShadingEnable;
@@ -2722,6 +2987,7 @@ void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipeline
     pSampleMask = nullptr;
     alphaToCoverageEnable = src->alphaToCoverageEnable;
     alphaToOneEnable = src->alphaToOneEnable;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pSampleMask) {
         pSampleMask = new VkSampleMask(*src->pSampleMask);
     }
@@ -2729,7 +2995,6 @@ void safe_VkPipelineMultisampleStateCreateInfo::initialize(const safe_VkPipeline
 
 safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(const VkPipelineDepthStencilStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     depthTestEnable(in_struct->depthTestEnable),
     depthWriteEnable(in_struct->depthWriteEnable),
@@ -2741,15 +3006,16 @@ safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCrea
     minDepthBounds(in_struct->minDepthBounds),
     maxDepthBounds(in_struct->maxDepthBounds)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo()
+safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCreateInfo(const safe_VkPipelineDepthStencilStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     depthTestEnable = src.depthTestEnable;
     depthWriteEnable = src.depthWriteEnable;
@@ -2760,15 +3026,17 @@ safe_VkPipelineDepthStencilStateCreateInfo::safe_VkPipelineDepthStencilStateCrea
     back = src.back;
     minDepthBounds = src.minDepthBounds;
     maxDepthBounds = src.maxDepthBounds;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineDepthStencilStateCreateInfo& safe_VkPipelineDepthStencilStateCreateInfo::operator=(const safe_VkPipelineDepthStencilStateCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     depthTestEnable = src.depthTestEnable;
     depthWriteEnable = src.depthWriteEnable;
@@ -2779,18 +3047,20 @@ safe_VkPipelineDepthStencilStateCreateInfo& safe_VkPipelineDepthStencilStateCrea
     back = src.back;
     minDepthBounds = src.minDepthBounds;
     maxDepthBounds = src.maxDepthBounds;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineDepthStencilStateCreateInfo::~safe_VkPipelineDepthStencilStateCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDepthStencilStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     depthTestEnable = in_struct->depthTestEnable;
     depthWriteEnable = in_struct->depthWriteEnable;
@@ -2801,12 +3071,12 @@ void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const VkPipelineDept
     back = in_struct->back;
     minDepthBounds = in_struct->minDepthBounds;
     maxDepthBounds = in_struct->maxDepthBounds;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelineDepthStencilStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     depthTestEnable = src->depthTestEnable;
     depthWriteEnable = src->depthWriteEnable;
@@ -2817,44 +3087,46 @@ void safe_VkPipelineDepthStencilStateCreateInfo::initialize(const safe_VkPipelin
     back = src->back;
     minDepthBounds = src->minDepthBounds;
     maxDepthBounds = src->maxDepthBounds;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(const VkPipelineColorBlendStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     logicOpEnable(in_struct->logicOpEnable),
     logicOp(in_struct->logicOp),
     attachmentCount(in_struct->attachmentCount),
     pAttachments(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttachments) {
         pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
         memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*in_struct->attachmentCount);
     }
-    for (uint32_t i=0; i<4; ++i) {
+    for (uint32_t i = 0; i < 4; ++i) {
         blendConstants[i] = in_struct->blendConstants[i];
     }
 }
 
 safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo() :
+    pNext(nullptr),
     pAttachments(nullptr)
 {}
 
 safe_VkPipelineColorBlendStateCreateInfo::safe_VkPipelineColorBlendStateCreateInfo(const safe_VkPipelineColorBlendStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     logicOpEnable = src.logicOpEnable;
     logicOp = src.logicOp;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttachments) {
         pAttachments = new VkPipelineColorBlendAttachmentState[src.attachmentCount];
         memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*src.attachmentCount);
     }
-    for (uint32_t i=0; i<4; ++i) {
+    for (uint32_t i = 0; i < 4; ++i) {
         blendConstants[i] = src.blendConstants[i];
     }
 }
@@ -2865,19 +3137,21 @@ safe_VkPipelineColorBlendStateCreateInfo& safe_VkPipelineColorBlendStateCreateIn
 
     if (pAttachments)
         delete[] pAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     logicOpEnable = src.logicOpEnable;
     logicOp = src.logicOp;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttachments) {
         pAttachments = new VkPipelineColorBlendAttachmentState[src.attachmentCount];
         memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*src.attachmentCount);
     }
-    for (uint32_t i=0; i<4; ++i) {
+    for (uint32_t i = 0; i < 4; ++i) {
         blendConstants[i] = src.blendConstants[i];
     }
 
@@ -2888,22 +3162,24 @@ safe_VkPipelineColorBlendStateCreateInfo::~safe_VkPipelineColorBlendStateCreateI
 {
     if (pAttachments)
         delete[] pAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorBlendStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     logicOpEnable = in_struct->logicOpEnable;
     logicOp = in_struct->logicOp;
     attachmentCount = in_struct->attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttachments) {
         pAttachments = new VkPipelineColorBlendAttachmentState[in_struct->attachmentCount];
         memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*in_struct->attachmentCount);
     }
-    for (uint32_t i=0; i<4; ++i) {
+    for (uint32_t i = 0; i < 4; ++i) {
         blendConstants[i] = in_struct->blendConstants[i];
     }
 }
@@ -2911,28 +3187,28 @@ void safe_VkPipelineColorBlendStateCreateInfo::initialize(const VkPipelineColorB
 void safe_VkPipelineColorBlendStateCreateInfo::initialize(const safe_VkPipelineColorBlendStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     logicOpEnable = src->logicOpEnable;
     logicOp = src->logicOp;
     attachmentCount = src->attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAttachments) {
         pAttachments = new VkPipelineColorBlendAttachmentState[src->attachmentCount];
         memcpy ((void *)pAttachments, (void *)src->pAttachments, sizeof(VkPipelineColorBlendAttachmentState)*src->attachmentCount);
     }
-    for (uint32_t i=0; i<4; ++i) {
+    for (uint32_t i = 0; i < 4; ++i) {
         blendConstants[i] = src->blendConstants[i];
     }
 }
 
 safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const VkPipelineDynamicStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     dynamicStateCount(in_struct->dynamicStateCount),
     pDynamicStates(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDynamicStates) {
         pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
         memcpy ((void *)pDynamicStates, (void *)in_struct->pDynamicStates, sizeof(VkDynamicState)*in_struct->dynamicStateCount);
@@ -2940,16 +3216,17 @@ safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(con
 }
 
 safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo() :
+    pNext(nullptr),
     pDynamicStates(nullptr)
 {}
 
 safe_VkPipelineDynamicStateCreateInfo::safe_VkPipelineDynamicStateCreateInfo(const safe_VkPipelineDynamicStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     dynamicStateCount = src.dynamicStateCount;
     pDynamicStates = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDynamicStates) {
         pDynamicStates = new VkDynamicState[src.dynamicStateCount];
         memcpy ((void *)pDynamicStates, (void *)src.pDynamicStates, sizeof(VkDynamicState)*src.dynamicStateCount);
@@ -2962,12 +3239,14 @@ safe_VkPipelineDynamicStateCreateInfo& safe_VkPipelineDynamicStateCreateInfo::op
 
     if (pDynamicStates)
         delete[] pDynamicStates;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     dynamicStateCount = src.dynamicStateCount;
     pDynamicStates = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDynamicStates) {
         pDynamicStates = new VkDynamicState[src.dynamicStateCount];
         memcpy ((void *)pDynamicStates, (void *)src.pDynamicStates, sizeof(VkDynamicState)*src.dynamicStateCount);
@@ -2980,15 +3259,17 @@ safe_VkPipelineDynamicStateCreateInfo::~safe_VkPipelineDynamicStateCreateInfo()
 {
     if (pDynamicStates)
         delete[] pDynamicStates;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     dynamicStateCount = in_struct->dynamicStateCount;
     pDynamicStates = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDynamicStates) {
         pDynamicStates = new VkDynamicState[in_struct->dynamicStateCount];
         memcpy ((void *)pDynamicStates, (void *)in_struct->pDynamicStates, sizeof(VkDynamicState)*in_struct->dynamicStateCount);
@@ -2998,10 +3279,10 @@ void safe_VkPipelineDynamicStateCreateInfo::initialize(const VkPipelineDynamicSt
 void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDynamicStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     dynamicStateCount = src->dynamicStateCount;
     pDynamicStates = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDynamicStates) {
         pDynamicStates = new VkDynamicState[src->dynamicStateCount];
         memcpy ((void *)pDynamicStates, (void *)src->pDynamicStates, sizeof(VkDynamicState)*src->dynamicStateCount);
@@ -3010,19 +3291,28 @@ void safe_VkPipelineDynamicStateCreateInfo::initialize(const safe_VkPipelineDyna
 
 safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     stageCount(in_struct->stageCount),
     pStages(nullptr),
+    pVertexInputState(nullptr),
+    pInputAssemblyState(nullptr),
+    pTessellationState(nullptr),
+    pViewportState(nullptr),
+    pRasterizationState(nullptr),
+    pMultisampleState(nullptr),
+    pDepthStencilState(nullptr),
+    pColorBlendState(nullptr),
+    pDynamicState(nullptr),
     layout(in_struct->layout),
     renderPass(in_struct->renderPass),
     subpass(in_struct->subpass),
     basePipelineHandle(in_struct->basePipelineHandle),
     basePipelineIndex(in_struct->basePipelineIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (stageCount && in_struct->pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&in_struct->pStages[i]);
         }
     }
@@ -3036,7 +3326,7 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
         pInputAssemblyState = NULL;
     bool has_tessellation_stage = false;
     if (stageCount && pStages)
-        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
     if (in_struct->pTessellationState && has_tessellation_stage)
@@ -3083,24 +3373,43 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const VkGra
 }
 
 safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo() :
-    pStages(nullptr)
+    pNext(nullptr),
+    pStages(nullptr),
+    pVertexInputState(nullptr),
+    pInputAssemblyState(nullptr),
+    pTessellationState(nullptr),
+    pViewportState(nullptr),
+    pRasterizationState(nullptr),
+    pMultisampleState(nullptr),
+    pDepthStencilState(nullptr),
+    pColorBlendState(nullptr),
+    pDynamicState(nullptr)
 {}
 
 safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_VkGraphicsPipelineCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stageCount = src.stageCount;
     pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
     layout = src.layout;
     renderPass = src.renderPass;
     subpass = src.subpass;
     basePipelineHandle = src.basePipelineHandle;
     basePipelineIndex = src.basePipelineIndex;
+    pNext = SafePnextCopy(src.pNext);
     if (stageCount && src.pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&src.pStages[i]);
         }
     }
@@ -3114,7 +3423,7 @@ safe_VkGraphicsPipelineCreateInfo::safe_VkGraphicsPipelineCreateInfo(const safe_
         pInputAssemblyState = NULL;
     bool has_tessellation_stage = false;
     if (stageCount && pStages)
-        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
     if (src.pTessellationState && has_tessellation_stage)
@@ -3172,20 +3481,31 @@ safe_VkGraphicsPipelineCreateInfo& safe_VkGraphicsPipelineCreateInfo::operator=(
         delete pColorBlendState;
     if (pDynamicState)
         delete pDynamicState;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stageCount = src.stageCount;
     pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
     layout = src.layout;
     renderPass = src.renderPass;
     subpass = src.subpass;
     basePipelineHandle = src.basePipelineHandle;
     basePipelineIndex = src.basePipelineIndex;
+    pNext = SafePnextCopy(src.pNext);
     if (stageCount && src.pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&src.pStages[i]);
         }
     }
@@ -3199,7 +3519,7 @@ safe_VkGraphicsPipelineCreateInfo& safe_VkGraphicsPipelineCreateInfo::operator=(
         pInputAssemblyState = NULL;
     bool has_tessellation_stage = false;
     if (stageCount && pStages)
-        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
     if (src.pTessellationState && has_tessellation_stage)
@@ -3257,23 +3577,34 @@ safe_VkGraphicsPipelineCreateInfo::~safe_VkGraphicsPipelineCreateInfo()
         delete pColorBlendState;
     if (pDynamicState)
         delete pDynamicState;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreateInfo* in_struct, const bool uses_color_attachment, const bool uses_depthstencil_attachment)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     stageCount = in_struct->stageCount;
     pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
     layout = in_struct->layout;
     renderPass = in_struct->renderPass;
     subpass = in_struct->subpass;
     basePipelineHandle = in_struct->basePipelineHandle;
     basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (stageCount && in_struct->pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&in_struct->pStages[i]);
         }
     }
@@ -3287,7 +3618,7 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
         pInputAssemblyState = NULL;
     bool has_tessellation_stage = false;
     if (stageCount && pStages)
-        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
     if (in_struct->pTessellationState && has_tessellation_stage)
@@ -3336,18 +3667,27 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const VkGraphicsPipelineCreat
 void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipelineCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     stageCount = src->stageCount;
     pStages = nullptr;
+    pVertexInputState = nullptr;
+    pInputAssemblyState = nullptr;
+    pTessellationState = nullptr;
+    pViewportState = nullptr;
+    pRasterizationState = nullptr;
+    pMultisampleState = nullptr;
+    pDepthStencilState = nullptr;
+    pColorBlendState = nullptr;
+    pDynamicState = nullptr;
     layout = src->layout;
     renderPass = src->renderPass;
     subpass = src->subpass;
     basePipelineHandle = src->basePipelineHandle;
     basePipelineIndex = src->basePipelineIndex;
+    pNext = SafePnextCopy(src->pNext);
     if (stageCount && src->pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&src->pStages[i]);
         }
     }
@@ -3361,7 +3701,7 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipeline
         pInputAssemblyState = NULL;
     bool has_tessellation_stage = false;
     if (stageCount && pStages)
-        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)
+        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)
             if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)
                 has_tessellation_stage = true;
     if (src->pTessellationState && has_tessellation_stage)
@@ -3397,83 +3737,88 @@ void safe_VkGraphicsPipelineCreateInfo::initialize(const safe_VkGraphicsPipeline
 
 safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const VkComputePipelineCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     stage(&in_struct->stage),
     layout(in_struct->layout),
     basePipelineHandle(in_struct->basePipelineHandle),
     basePipelineIndex(in_struct->basePipelineIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo()
+safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkComputePipelineCreateInfo::safe_VkComputePipelineCreateInfo(const safe_VkComputePipelineCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stage.initialize(&src.stage);
     layout = src.layout;
     basePipelineHandle = src.basePipelineHandle;
     basePipelineIndex = src.basePipelineIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkComputePipelineCreateInfo& safe_VkComputePipelineCreateInfo::operator=(const safe_VkComputePipelineCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stage.initialize(&src.stage);
     layout = src.layout;
     basePipelineHandle = src.basePipelineHandle;
     basePipelineIndex = src.basePipelineIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkComputePipelineCreateInfo::~safe_VkComputePipelineCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkComputePipelineCreateInfo::initialize(const VkComputePipelineCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     stage.initialize(&in_struct->stage);
     layout = in_struct->layout;
     basePipelineHandle = in_struct->basePipelineHandle;
     basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkComputePipelineCreateInfo::initialize(const safe_VkComputePipelineCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     stage.initialize(&src->stage);
     layout = src->layout;
     basePipelineHandle = src->basePipelineHandle;
     basePipelineIndex = src->basePipelineIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     setLayoutCount(in_struct->setLayoutCount),
     pSetLayouts(nullptr),
     pushConstantRangeCount(in_struct->pushConstantRangeCount),
     pPushConstantRanges(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (setLayoutCount && in_struct->pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
-        for (uint32_t i=0; i<setLayoutCount; ++i) {
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
             pSetLayouts[i] = in_struct->pSetLayouts[i];
         }
     }
@@ -3484,6 +3829,7 @@ safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const VkPipelin
 }
 
 safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo() :
+    pNext(nullptr),
     pSetLayouts(nullptr),
     pPushConstantRanges(nullptr)
 {}
@@ -3491,15 +3837,15 @@ safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo() :
 safe_VkPipelineLayoutCreateInfo::safe_VkPipelineLayoutCreateInfo(const safe_VkPipelineLayoutCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     setLayoutCount = src.setLayoutCount;
     pSetLayouts = nullptr;
     pushConstantRangeCount = src.pushConstantRangeCount;
     pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (setLayoutCount && src.pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
-        for (uint32_t i=0; i<setLayoutCount; ++i) {
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
             pSetLayouts[i] = src.pSetLayouts[i];
         }
     }
@@ -3517,17 +3863,19 @@ safe_VkPipelineLayoutCreateInfo& safe_VkPipelineLayoutCreateInfo::operator=(cons
         delete[] pSetLayouts;
     if (pPushConstantRanges)
         delete[] pPushConstantRanges;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     setLayoutCount = src.setLayoutCount;
     pSetLayouts = nullptr;
     pushConstantRangeCount = src.pushConstantRangeCount;
     pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (setLayoutCount && src.pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
-        for (uint32_t i=0; i<setLayoutCount; ++i) {
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
             pSetLayouts[i] = src.pSetLayouts[i];
         }
     }
@@ -3545,20 +3893,22 @@ safe_VkPipelineLayoutCreateInfo::~safe_VkPipelineLayoutCreateInfo()
         delete[] pSetLayouts;
     if (pPushConstantRanges)
         delete[] pPushConstantRanges;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineLayoutCreateInfo::initialize(const VkPipelineLayoutCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     setLayoutCount = in_struct->setLayoutCount;
     pSetLayouts = nullptr;
     pushConstantRangeCount = in_struct->pushConstantRangeCount;
     pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (setLayoutCount && in_struct->pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
-        for (uint32_t i=0; i<setLayoutCount; ++i) {
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
             pSetLayouts[i] = in_struct->pSetLayouts[i];
         }
     }
@@ -3571,15 +3921,15 @@ void safe_VkPipelineLayoutCreateInfo::initialize(const VkPipelineLayoutCreateInf
 void safe_VkPipelineLayoutCreateInfo::initialize(const safe_VkPipelineLayoutCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     setLayoutCount = src->setLayoutCount;
     pSetLayouts = nullptr;
     pushConstantRangeCount = src->pushConstantRangeCount;
     pPushConstantRanges = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (setLayoutCount && src->pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[setLayoutCount];
-        for (uint32_t i=0; i<setLayoutCount; ++i) {
+        for (uint32_t i = 0; i < setLayoutCount; ++i) {
             pSetLayouts[i] = src->pSetLayouts[i];
         }
     }
@@ -3591,7 +3941,6 @@ void safe_VkPipelineLayoutCreateInfo::initialize(const safe_VkPipelineLayoutCrea
 
 safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     magFilter(in_struct->magFilter),
     minFilter(in_struct->minFilter),
@@ -3609,15 +3958,16 @@ safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const VkSamplerCreateInfo* in
     borderColor(in_struct->borderColor),
     unnormalizedCoordinates(in_struct->unnormalizedCoordinates)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo()
+safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     magFilter = src.magFilter;
     minFilter = src.minFilter;
@@ -3634,15 +3984,17 @@ safe_VkSamplerCreateInfo::safe_VkSamplerCreateInfo(const safe_VkSamplerCreateInf
     maxLod = src.maxLod;
     borderColor = src.borderColor;
     unnormalizedCoordinates = src.unnormalizedCoordinates;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSamplerCreateInfo& safe_VkSamplerCreateInfo::operator=(const safe_VkSamplerCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     magFilter = src.magFilter;
     minFilter = src.minFilter;
@@ -3659,18 +4011,20 @@ safe_VkSamplerCreateInfo& safe_VkSamplerCreateInfo::operator=(const safe_VkSampl
     maxLod = src.maxLod;
     borderColor = src.borderColor;
     unnormalizedCoordinates = src.unnormalizedCoordinates;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSamplerCreateInfo::~safe_VkSamplerCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSamplerCreateInfo::initialize(const VkSamplerCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     magFilter = in_struct->magFilter;
     minFilter = in_struct->minFilter;
@@ -3687,12 +4041,12 @@ void safe_VkSamplerCreateInfo::initialize(const VkSamplerCreateInfo* in_struct)
     maxLod = in_struct->maxLod;
     borderColor = in_struct->borderColor;
     unnormalizedCoordinates = in_struct->unnormalizedCoordinates;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSamplerCreateInfo::initialize(const safe_VkSamplerCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     magFilter = src->magFilter;
     minFilter = src->minFilter;
@@ -3709,6 +4063,7 @@ void safe_VkSamplerCreateInfo::initialize(const safe_VkSamplerCreateInfo* src)
     maxLod = src->maxLod;
     borderColor = src->borderColor;
     unnormalizedCoordinates = src->unnormalizedCoordinates;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding* in_struct) :
@@ -3721,7 +4076,7 @@ safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const VkDes
     const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
         pImmutableSamplers = new VkSampler[descriptorCount];
-        for (uint32_t i=0; i<descriptorCount; ++i) {
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
             pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
         }
     }
@@ -3741,7 +4096,7 @@ safe_VkDescriptorSetLayoutBinding::safe_VkDescriptorSetLayoutBinding(const safe_
     const bool sampler_type = src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     if (descriptorCount && src.pImmutableSamplers && sampler_type) {
         pImmutableSamplers = new VkSampler[descriptorCount];
-        for (uint32_t i=0; i<descriptorCount; ++i) {
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
             pImmutableSamplers[i] = src.pImmutableSamplers[i];
         }
     }
@@ -3762,7 +4117,7 @@ safe_VkDescriptorSetLayoutBinding& safe_VkDescriptorSetLayoutBinding::operator=(
     const bool sampler_type = src.descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || src.descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     if (descriptorCount && src.pImmutableSamplers && sampler_type) {
         pImmutableSamplers = new VkSampler[descriptorCount];
-        for (uint32_t i=0; i<descriptorCount; ++i) {
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
             pImmutableSamplers[i] = src.pImmutableSamplers[i];
         }
     }
@@ -3786,7 +4141,7 @@ void safe_VkDescriptorSetLayoutBinding::initialize(const VkDescriptorSetLayoutBi
     const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {
         pImmutableSamplers = new VkSampler[descriptorCount];
-        for (uint32_t i=0; i<descriptorCount; ++i) {
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
             pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];
         }
     }
@@ -3802,7 +4157,7 @@ void safe_VkDescriptorSetLayoutBinding::initialize(const safe_VkDescriptorSetLay
     const bool sampler_type = src->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || src->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     if (descriptorCount && src->pImmutableSamplers && sampler_type) {
         pImmutableSamplers = new VkSampler[descriptorCount];
-        for (uint32_t i=0; i<descriptorCount; ++i) {
+        for (uint32_t i = 0; i < descriptorCount; ++i) {
             pImmutableSamplers[i] = src->pImmutableSamplers[i];
         }
     }
@@ -3810,33 +4165,34 @@ void safe_VkDescriptorSetLayoutBinding::initialize(const safe_VkDescriptorSetLay
 
 safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     bindingCount(in_struct->bindingCount),
     pBindings(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (bindingCount && in_struct->pBindings) {
         pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
-        for (uint32_t i=0; i<bindingCount; ++i) {
+        for (uint32_t i = 0; i < bindingCount; ++i) {
             pBindings[i].initialize(&in_struct->pBindings[i]);
         }
     }
 }
 
 safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo() :
+    pNext(nullptr),
     pBindings(nullptr)
 {}
 
 safe_VkDescriptorSetLayoutCreateInfo::safe_VkDescriptorSetLayoutCreateInfo(const safe_VkDescriptorSetLayoutCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     bindingCount = src.bindingCount;
     pBindings = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (bindingCount && src.pBindings) {
         pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
-        for (uint32_t i=0; i<bindingCount; ++i) {
+        for (uint32_t i = 0; i < bindingCount; ++i) {
             pBindings[i].initialize(&src.pBindings[i]);
         }
     }
@@ -3848,15 +4204,17 @@ safe_VkDescriptorSetLayoutCreateInfo& safe_VkDescriptorSetLayoutCreateInfo::oper
 
     if (pBindings)
         delete[] pBindings;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     bindingCount = src.bindingCount;
     pBindings = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (bindingCount && src.pBindings) {
         pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
-        for (uint32_t i=0; i<bindingCount; ++i) {
+        for (uint32_t i = 0; i < bindingCount; ++i) {
             pBindings[i].initialize(&src.pBindings[i]);
         }
     }
@@ -3868,18 +4226,20 @@ safe_VkDescriptorSetLayoutCreateInfo::~safe_VkDescriptorSetLayoutCreateInfo()
 {
     if (pBindings)
         delete[] pBindings;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorSetLayoutCreateInfo::initialize(const VkDescriptorSetLayoutCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     bindingCount = in_struct->bindingCount;
     pBindings = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (bindingCount && in_struct->pBindings) {
         pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
-        for (uint32_t i=0; i<bindingCount; ++i) {
+        for (uint32_t i = 0; i < bindingCount; ++i) {
             pBindings[i].initialize(&in_struct->pBindings[i]);
         }
     }
@@ -3888,13 +4248,13 @@ void safe_VkDescriptorSetLayoutCreateInfo::initialize(const VkDescriptorSetLayou
 void safe_VkDescriptorSetLayoutCreateInfo::initialize(const safe_VkDescriptorSetLayoutCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     bindingCount = src->bindingCount;
     pBindings = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (bindingCount && src->pBindings) {
         pBindings = new safe_VkDescriptorSetLayoutBinding[bindingCount];
-        for (uint32_t i=0; i<bindingCount; ++i) {
+        for (uint32_t i = 0; i < bindingCount; ++i) {
             pBindings[i].initialize(&src->pBindings[i]);
         }
     }
@@ -3902,12 +4262,12 @@ void safe_VkDescriptorSetLayoutCreateInfo::initialize(const safe_VkDescriptorSet
 
 safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     maxSets(in_struct->maxSets),
     poolSizeCount(in_struct->poolSizeCount),
     pPoolSizes(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPoolSizes) {
         pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
         memcpy ((void *)pPoolSizes, (void *)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize)*in_struct->poolSizeCount);
@@ -3915,17 +4275,18 @@ safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const VkDescrip
 }
 
 safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo() :
+    pNext(nullptr),
     pPoolSizes(nullptr)
 {}
 
 safe_VkDescriptorPoolCreateInfo::safe_VkDescriptorPoolCreateInfo(const safe_VkDescriptorPoolCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     maxSets = src.maxSets;
     poolSizeCount = src.poolSizeCount;
     pPoolSizes = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPoolSizes) {
         pPoolSizes = new VkDescriptorPoolSize[src.poolSizeCount];
         memcpy ((void *)pPoolSizes, (void *)src.pPoolSizes, sizeof(VkDescriptorPoolSize)*src.poolSizeCount);
@@ -3938,13 +4299,15 @@ safe_VkDescriptorPoolCreateInfo& safe_VkDescriptorPoolCreateInfo::operator=(cons
 
     if (pPoolSizes)
         delete[] pPoolSizes;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     maxSets = src.maxSets;
     poolSizeCount = src.poolSizeCount;
     pPoolSizes = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPoolSizes) {
         pPoolSizes = new VkDescriptorPoolSize[src.poolSizeCount];
         memcpy ((void *)pPoolSizes, (void *)src.pPoolSizes, sizeof(VkDescriptorPoolSize)*src.poolSizeCount);
@@ -3957,16 +4320,18 @@ safe_VkDescriptorPoolCreateInfo::~safe_VkDescriptorPoolCreateInfo()
 {
     if (pPoolSizes)
         delete[] pPoolSizes;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorPoolCreateInfo::initialize(const VkDescriptorPoolCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     maxSets = in_struct->maxSets;
     poolSizeCount = in_struct->poolSizeCount;
     pPoolSizes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPoolSizes) {
         pPoolSizes = new VkDescriptorPoolSize[in_struct->poolSizeCount];
         memcpy ((void *)pPoolSizes, (void *)in_struct->pPoolSizes, sizeof(VkDescriptorPoolSize)*in_struct->poolSizeCount);
@@ -3976,11 +4341,11 @@ void safe_VkDescriptorPoolCreateInfo::initialize(const VkDescriptorPoolCreateInf
 void safe_VkDescriptorPoolCreateInfo::initialize(const safe_VkDescriptorPoolCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     maxSets = src->maxSets;
     poolSizeCount = src->poolSizeCount;
     pPoolSizes = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pPoolSizes) {
         pPoolSizes = new VkDescriptorPoolSize[src->poolSizeCount];
         memcpy ((void *)pPoolSizes, (void *)src->pPoolSizes, sizeof(VkDescriptorPoolSize)*src->poolSizeCount);
@@ -3989,33 +4354,34 @@ void safe_VkDescriptorPoolCreateInfo::initialize(const safe_VkDescriptorPoolCrea
 
 safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     descriptorPool(in_struct->descriptorPool),
     descriptorSetCount(in_struct->descriptorSetCount),
     pSetLayouts(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (descriptorSetCount && in_struct->pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
-        for (uint32_t i=0; i<descriptorSetCount; ++i) {
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
             pSetLayouts[i] = in_struct->pSetLayouts[i];
         }
     }
 }
 
 safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo() :
+    pNext(nullptr),
     pSetLayouts(nullptr)
 {}
 
 safe_VkDescriptorSetAllocateInfo::safe_VkDescriptorSetAllocateInfo(const safe_VkDescriptorSetAllocateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     descriptorPool = src.descriptorPool;
     descriptorSetCount = src.descriptorSetCount;
     pSetLayouts = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (descriptorSetCount && src.pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
-        for (uint32_t i=0; i<descriptorSetCount; ++i) {
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
             pSetLayouts[i] = src.pSetLayouts[i];
         }
     }
@@ -4027,15 +4393,17 @@ safe_VkDescriptorSetAllocateInfo& safe_VkDescriptorSetAllocateInfo::operator=(co
 
     if (pSetLayouts)
         delete[] pSetLayouts;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     descriptorPool = src.descriptorPool;
     descriptorSetCount = src.descriptorSetCount;
     pSetLayouts = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (descriptorSetCount && src.pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
-        for (uint32_t i=0; i<descriptorSetCount; ++i) {
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
             pSetLayouts[i] = src.pSetLayouts[i];
         }
     }
@@ -4047,18 +4415,20 @@ safe_VkDescriptorSetAllocateInfo::~safe_VkDescriptorSetAllocateInfo()
 {
     if (pSetLayouts)
         delete[] pSetLayouts;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorSetAllocateInfo::initialize(const VkDescriptorSetAllocateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     descriptorPool = in_struct->descriptorPool;
     descriptorSetCount = in_struct->descriptorSetCount;
     pSetLayouts = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (descriptorSetCount && in_struct->pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
-        for (uint32_t i=0; i<descriptorSetCount; ++i) {
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
             pSetLayouts[i] = in_struct->pSetLayouts[i];
         }
     }
@@ -4067,13 +4437,13 @@ void safe_VkDescriptorSetAllocateInfo::initialize(const VkDescriptorSetAllocateI
 void safe_VkDescriptorSetAllocateInfo::initialize(const safe_VkDescriptorSetAllocateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     descriptorPool = src->descriptorPool;
     descriptorSetCount = src->descriptorSetCount;
     pSetLayouts = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (descriptorSetCount && src->pSetLayouts) {
         pSetLayouts = new VkDescriptorSetLayout[descriptorSetCount];
-        for (uint32_t i=0; i<descriptorSetCount; ++i) {
+        for (uint32_t i = 0; i < descriptorSetCount; ++i) {
             pSetLayouts[i] = src->pSetLayouts[i];
         }
     }
@@ -4081,7 +4451,6 @@ void safe_VkDescriptorSetAllocateInfo::initialize(const safe_VkDescriptorSetAllo
 
 safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     dstSet(in_struct->dstSet),
     dstBinding(in_struct->dstBinding),
     dstArrayElement(in_struct->dstArrayElement),
@@ -4091,6 +4460,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet*
     pBufferInfo(nullptr),
     pTexelBufferView(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     switch (descriptorType) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
@@ -4099,7 +4469,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet*
         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
         if (descriptorCount && in_struct->pImageInfo) {
             pImageInfo = new VkDescriptorImageInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pImageInfo[i] = in_struct->pImageInfo[i];
             }
         }
@@ -4110,7 +4480,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet*
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
         if (descriptorCount && in_struct->pBufferInfo) {
             pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pBufferInfo[i] = in_struct->pBufferInfo[i];
             }
         }
@@ -4119,7 +4489,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet*
         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
         if (descriptorCount && in_struct->pTexelBufferView) {
             pTexelBufferView = new VkBufferView[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pTexelBufferView[i] = in_struct->pTexelBufferView[i];
             }
         }
@@ -4130,6 +4500,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const VkWriteDescriptorSet*
 }
 
 safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet() :
+    pNext(nullptr),
     pImageInfo(nullptr),
     pBufferInfo(nullptr),
     pTexelBufferView(nullptr)
@@ -4138,7 +4509,6 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet() :
 safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescriptorSet& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     dstSet = src.dstSet;
     dstBinding = src.dstBinding;
     dstArrayElement = src.dstArrayElement;
@@ -4147,6 +4517,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescripto
     pImageInfo = nullptr;
     pBufferInfo = nullptr;
     pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     switch (descriptorType) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
@@ -4155,7 +4526,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescripto
         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
         if (descriptorCount && src.pImageInfo) {
             pImageInfo = new VkDescriptorImageInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pImageInfo[i] = src.pImageInfo[i];
             }
         }
@@ -4166,7 +4537,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescripto
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
         if (descriptorCount && src.pBufferInfo) {
             pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pBufferInfo[i] = src.pBufferInfo[i];
             }
         }
@@ -4175,7 +4546,7 @@ safe_VkWriteDescriptorSet::safe_VkWriteDescriptorSet(const safe_VkWriteDescripto
         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
         if (descriptorCount && src.pTexelBufferView) {
             pTexelBufferView = new VkBufferView[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pTexelBufferView[i] = src.pTexelBufferView[i];
             }
         }
@@ -4195,9 +4566,10 @@ safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWri
         delete[] pBufferInfo;
     if (pTexelBufferView)
         delete[] pTexelBufferView;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     dstSet = src.dstSet;
     dstBinding = src.dstBinding;
     dstArrayElement = src.dstArrayElement;
@@ -4206,6 +4578,7 @@ safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWri
     pImageInfo = nullptr;
     pBufferInfo = nullptr;
     pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     switch (descriptorType) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
@@ -4214,7 +4587,7 @@ safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWri
         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
         if (descriptorCount && src.pImageInfo) {
             pImageInfo = new VkDescriptorImageInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pImageInfo[i] = src.pImageInfo[i];
             }
         }
@@ -4225,7 +4598,7 @@ safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWri
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
         if (descriptorCount && src.pBufferInfo) {
             pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pBufferInfo[i] = src.pBufferInfo[i];
             }
         }
@@ -4234,7 +4607,7 @@ safe_VkWriteDescriptorSet& safe_VkWriteDescriptorSet::operator=(const safe_VkWri
         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
         if (descriptorCount && src.pTexelBufferView) {
             pTexelBufferView = new VkBufferView[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pTexelBufferView[i] = src.pTexelBufferView[i];
             }
         }
@@ -4254,12 +4627,13 @@ safe_VkWriteDescriptorSet::~safe_VkWriteDescriptorSet()
         delete[] pBufferInfo;
     if (pTexelBufferView)
         delete[] pTexelBufferView;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     dstSet = in_struct->dstSet;
     dstBinding = in_struct->dstBinding;
     dstArrayElement = in_struct->dstArrayElement;
@@ -4268,6 +4642,7 @@ void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct
     pImageInfo = nullptr;
     pBufferInfo = nullptr;
     pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     switch (descriptorType) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
@@ -4276,7 +4651,7 @@ void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct
         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
         if (descriptorCount && in_struct->pImageInfo) {
             pImageInfo = new VkDescriptorImageInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pImageInfo[i] = in_struct->pImageInfo[i];
             }
         }
@@ -4287,7 +4662,7 @@ void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
         if (descriptorCount && in_struct->pBufferInfo) {
             pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pBufferInfo[i] = in_struct->pBufferInfo[i];
             }
         }
@@ -4296,7 +4671,7 @@ void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct
         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
         if (descriptorCount && in_struct->pTexelBufferView) {
             pTexelBufferView = new VkBufferView[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pTexelBufferView[i] = in_struct->pTexelBufferView[i];
             }
         }
@@ -4309,7 +4684,6 @@ void safe_VkWriteDescriptorSet::initialize(const VkWriteDescriptorSet* in_struct
 void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     dstSet = src->dstSet;
     dstBinding = src->dstBinding;
     dstArrayElement = src->dstArrayElement;
@@ -4318,6 +4692,7 @@ void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
     pImageInfo = nullptr;
     pBufferInfo = nullptr;
     pTexelBufferView = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     switch (descriptorType) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
@@ -4326,7 +4701,7 @@ void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
         if (descriptorCount && src->pImageInfo) {
             pImageInfo = new VkDescriptorImageInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pImageInfo[i] = src->pImageInfo[i];
             }
         }
@@ -4337,7 +4712,7 @@ void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
         if (descriptorCount && src->pBufferInfo) {
             pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pBufferInfo[i] = src->pBufferInfo[i];
             }
         }
@@ -4346,7 +4721,7 @@ void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
         if (descriptorCount && src->pTexelBufferView) {
             pTexelBufferView = new VkBufferView[descriptorCount];
-            for (uint32_t i=0; i<descriptorCount; ++i) {
+            for (uint32_t i = 0; i < descriptorCount; ++i) {
                 pTexelBufferView[i] = src->pTexelBufferView[i];
             }
         }
@@ -4358,7 +4733,6 @@ void safe_VkWriteDescriptorSet::initialize(const safe_VkWriteDescriptorSet* src)
 
 safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     srcSet(in_struct->srcSet),
     srcBinding(in_struct->srcBinding),
     srcArrayElement(in_struct->srcArrayElement),
@@ -4367,15 +4741,16 @@ safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const VkCopyDescriptorSet* in
     dstArrayElement(in_struct->dstArrayElement),
     descriptorCount(in_struct->descriptorCount)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet()
+safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet() :
+    pNext(nullptr)
 {}
 
 safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSet& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     srcSet = src.srcSet;
     srcBinding = src.srcBinding;
     srcArrayElement = src.srcArrayElement;
@@ -4383,15 +4758,17 @@ safe_VkCopyDescriptorSet::safe_VkCopyDescriptorSet(const safe_VkCopyDescriptorSe
     dstBinding = src.dstBinding;
     dstArrayElement = src.dstArrayElement;
     descriptorCount = src.descriptorCount;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCopyDescriptorSet& safe_VkCopyDescriptorSet::operator=(const safe_VkCopyDescriptorSet& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     srcSet = src.srcSet;
     srcBinding = src.srcBinding;
     srcArrayElement = src.srcArrayElement;
@@ -4399,18 +4776,20 @@ safe_VkCopyDescriptorSet& safe_VkCopyDescriptorSet::operator=(const safe_VkCopyD
     dstBinding = src.dstBinding;
     dstArrayElement = src.dstArrayElement;
     descriptorCount = src.descriptorCount;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCopyDescriptorSet::~safe_VkCopyDescriptorSet()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCopyDescriptorSet::initialize(const VkCopyDescriptorSet* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     srcSet = in_struct->srcSet;
     srcBinding = in_struct->srcBinding;
     srcArrayElement = in_struct->srcArrayElement;
@@ -4418,12 +4797,12 @@ void safe_VkCopyDescriptorSet::initialize(const VkCopyDescriptorSet* in_struct)
     dstBinding = in_struct->dstBinding;
     dstArrayElement = in_struct->dstArrayElement;
     descriptorCount = in_struct->descriptorCount;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCopyDescriptorSet::initialize(const safe_VkCopyDescriptorSet* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     srcSet = src->srcSet;
     srcBinding = src->srcBinding;
     srcArrayElement = src->srcArrayElement;
@@ -4431,11 +4810,11 @@ void safe_VkCopyDescriptorSet::initialize(const safe_VkCopyDescriptorSet* src)
     dstBinding = src->dstBinding;
     dstArrayElement = src->dstArrayElement;
     descriptorCount = src->descriptorCount;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const VkFramebufferCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     renderPass(in_struct->renderPass),
     attachmentCount(in_struct->attachmentCount),
@@ -4444,22 +4823,23 @@ safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const VkFramebufferCr
     height(in_struct->height),
     layers(in_struct->layers)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentCount && in_struct->pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = in_struct->pAttachments[i];
         }
     }
 }
 
 safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo() :
+    pNext(nullptr),
     pAttachments(nullptr)
 {}
 
 safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const safe_VkFramebufferCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     renderPass = src.renderPass;
     attachmentCount = src.attachmentCount;
@@ -4467,9 +4847,10 @@ safe_VkFramebufferCreateInfo::safe_VkFramebufferCreateInfo(const safe_VkFramebuf
     width = src.width;
     height = src.height;
     layers = src.layers;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentCount && src.pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = src.pAttachments[i];
         }
     }
@@ -4481,9 +4862,10 @@ safe_VkFramebufferCreateInfo& safe_VkFramebufferCreateInfo::operator=(const safe
 
     if (pAttachments)
         delete[] pAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     renderPass = src.renderPass;
     attachmentCount = src.attachmentCount;
@@ -4491,9 +4873,10 @@ safe_VkFramebufferCreateInfo& safe_VkFramebufferCreateInfo::operator=(const safe
     width = src.width;
     height = src.height;
     layers = src.layers;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentCount && src.pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = src.pAttachments[i];
         }
     }
@@ -4505,12 +4888,13 @@ safe_VkFramebufferCreateInfo::~safe_VkFramebufferCreateInfo()
 {
     if (pAttachments)
         delete[] pAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFramebufferCreateInfo::initialize(const VkFramebufferCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     renderPass = in_struct->renderPass;
     attachmentCount = in_struct->attachmentCount;
@@ -4518,9 +4902,10 @@ void safe_VkFramebufferCreateInfo::initialize(const VkFramebufferCreateInfo* in_
     width = in_struct->width;
     height = in_struct->height;
     layers = in_struct->layers;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentCount && in_struct->pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = in_struct->pAttachments[i];
         }
     }
@@ -4529,7 +4914,6 @@ void safe_VkFramebufferCreateInfo::initialize(const VkFramebufferCreateInfo* in_
 void safe_VkFramebufferCreateInfo::initialize(const safe_VkFramebufferCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     renderPass = src->renderPass;
     attachmentCount = src->attachmentCount;
@@ -4537,9 +4921,10 @@ void safe_VkFramebufferCreateInfo::initialize(const safe_VkFramebufferCreateInfo
     width = src->width;
     height = src->height;
     layers = src->layers;
+    pNext = SafePnextCopy(src->pNext);
     if (attachmentCount && src->pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = src->pAttachments[i];
         }
     }
@@ -4749,7 +5134,6 @@ void safe_VkSubpassDescription::initialize(const safe_VkSubpassDescription* src)
 
 safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const VkRenderPassCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     attachmentCount(in_struct->attachmentCount),
     pAttachments(nullptr),
@@ -4758,13 +5142,14 @@ safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const VkRenderPassCreat
     dependencyCount(in_struct->dependencyCount),
     pDependencies(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttachments) {
         pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
         memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkAttachmentDescription)*in_struct->attachmentCount);
     }
     if (subpassCount && in_struct->pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
         }
     }
@@ -4775,6 +5160,7 @@ safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const VkRenderPassCreat
 }
 
 safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo() :
+    pNext(nullptr),
     pAttachments(nullptr),
     pSubpasses(nullptr),
     pDependencies(nullptr)
@@ -4783,7 +5169,6 @@ safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo() :
 safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const safe_VkRenderPassCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
@@ -4791,13 +5176,14 @@ safe_VkRenderPassCreateInfo::safe_VkRenderPassCreateInfo(const safe_VkRenderPass
     pSubpasses = nullptr;
     dependencyCount = src.dependencyCount;
     pDependencies = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttachments) {
         pAttachments = new VkAttachmentDescription[src.attachmentCount];
         memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkAttachmentDescription)*src.attachmentCount);
     }
     if (subpassCount && src.pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&src.pSubpasses[i]);
         }
     }
@@ -4817,9 +5203,10 @@ safe_VkRenderPassCreateInfo& safe_VkRenderPassCreateInfo::operator=(const safe_V
         delete[] pSubpasses;
     if (pDependencies)
         delete[] pDependencies;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
@@ -4827,13 +5214,14 @@ safe_VkRenderPassCreateInfo& safe_VkRenderPassCreateInfo::operator=(const safe_V
     pSubpasses = nullptr;
     dependencyCount = src.dependencyCount;
     pDependencies = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttachments) {
         pAttachments = new VkAttachmentDescription[src.attachmentCount];
         memcpy ((void *)pAttachments, (void *)src.pAttachments, sizeof(VkAttachmentDescription)*src.attachmentCount);
     }
     if (subpassCount && src.pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&src.pSubpasses[i]);
         }
     }
@@ -4853,12 +5241,13 @@ safe_VkRenderPassCreateInfo::~safe_VkRenderPassCreateInfo()
         delete[] pSubpasses;
     if (pDependencies)
         delete[] pDependencies;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassCreateInfo::initialize(const VkRenderPassCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     attachmentCount = in_struct->attachmentCount;
     pAttachments = nullptr;
@@ -4866,13 +5255,14 @@ void safe_VkRenderPassCreateInfo::initialize(const VkRenderPassCreateInfo* in_st
     pSubpasses = nullptr;
     dependencyCount = in_struct->dependencyCount;
     pDependencies = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttachments) {
         pAttachments = new VkAttachmentDescription[in_struct->attachmentCount];
         memcpy ((void *)pAttachments, (void *)in_struct->pAttachments, sizeof(VkAttachmentDescription)*in_struct->attachmentCount);
     }
     if (subpassCount && in_struct->pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
         }
     }
@@ -4885,7 +5275,6 @@ void safe_VkRenderPassCreateInfo::initialize(const VkRenderPassCreateInfo* in_st
 void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     attachmentCount = src->attachmentCount;
     pAttachments = nullptr;
@@ -4893,13 +5282,14 @@ void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo*
     pSubpasses = nullptr;
     dependencyCount = src->dependencyCount;
     pDependencies = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAttachments) {
         pAttachments = new VkAttachmentDescription[src->attachmentCount];
         memcpy ((void *)pAttachments, (void *)src->pAttachments, sizeof(VkAttachmentDescription)*src->attachmentCount);
     }
     if (subpassCount && src->pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&src->pSubpasses[i]);
         }
     }
@@ -4911,116 +5301,125 @@ void safe_VkRenderPassCreateInfo::initialize(const safe_VkRenderPassCreateInfo*
 
 safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     queueFamilyIndex(in_struct->queueFamilyIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo()
+safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkCommandPoolCreateInfo::safe_VkCommandPoolCreateInfo(const safe_VkCommandPoolCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueFamilyIndex = src.queueFamilyIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCommandPoolCreateInfo& safe_VkCommandPoolCreateInfo::operator=(const safe_VkCommandPoolCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueFamilyIndex = src.queueFamilyIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCommandPoolCreateInfo::~safe_VkCommandPoolCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCommandPoolCreateInfo::initialize(const VkCommandPoolCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     queueFamilyIndex = in_struct->queueFamilyIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCommandPoolCreateInfo::initialize(const safe_VkCommandPoolCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     queueFamilyIndex = src->queueFamilyIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const VkCommandBufferAllocateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     commandPool(in_struct->commandPool),
     level(in_struct->level),
     commandBufferCount(in_struct->commandBufferCount)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo()
+safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkCommandBufferAllocateInfo::safe_VkCommandBufferAllocateInfo(const safe_VkCommandBufferAllocateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     commandPool = src.commandPool;
     level = src.level;
     commandBufferCount = src.commandBufferCount;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCommandBufferAllocateInfo& safe_VkCommandBufferAllocateInfo::operator=(const safe_VkCommandBufferAllocateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     commandPool = src.commandPool;
     level = src.level;
     commandBufferCount = src.commandBufferCount;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCommandBufferAllocateInfo::~safe_VkCommandBufferAllocateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCommandBufferAllocateInfo::initialize(const VkCommandBufferAllocateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     commandPool = in_struct->commandPool;
     level = in_struct->level;
     commandBufferCount = in_struct->commandBufferCount;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCommandBufferAllocateInfo::initialize(const safe_VkCommandBufferAllocateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     commandPool = src->commandPool;
     level = src->level;
     commandBufferCount = src->commandBufferCount;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const VkCommandBufferInheritanceInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     renderPass(in_struct->renderPass),
     subpass(in_struct->subpass),
     framebuffer(in_struct->framebuffer),
@@ -5028,91 +5427,97 @@ safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const V
     queryFlags(in_struct->queryFlags),
     pipelineStatistics(in_struct->pipelineStatistics)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo()
+safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkCommandBufferInheritanceInfo::safe_VkCommandBufferInheritanceInfo(const safe_VkCommandBufferInheritanceInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     renderPass = src.renderPass;
     subpass = src.subpass;
     framebuffer = src.framebuffer;
     occlusionQueryEnable = src.occlusionQueryEnable;
     queryFlags = src.queryFlags;
     pipelineStatistics = src.pipelineStatistics;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCommandBufferInheritanceInfo& safe_VkCommandBufferInheritanceInfo::operator=(const safe_VkCommandBufferInheritanceInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     renderPass = src.renderPass;
     subpass = src.subpass;
     framebuffer = src.framebuffer;
     occlusionQueryEnable = src.occlusionQueryEnable;
     queryFlags = src.queryFlags;
     pipelineStatistics = src.pipelineStatistics;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCommandBufferInheritanceInfo::~safe_VkCommandBufferInheritanceInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCommandBufferInheritanceInfo::initialize(const VkCommandBufferInheritanceInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     renderPass = in_struct->renderPass;
     subpass = in_struct->subpass;
     framebuffer = in_struct->framebuffer;
     occlusionQueryEnable = in_struct->occlusionQueryEnable;
     queryFlags = in_struct->queryFlags;
     pipelineStatistics = in_struct->pipelineStatistics;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCommandBufferInheritanceInfo::initialize(const safe_VkCommandBufferInheritanceInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     renderPass = src->renderPass;
     subpass = src->subpass;
     framebuffer = src->framebuffer;
     occlusionQueryEnable = src->occlusionQueryEnable;
     queryFlags = src->queryFlags;
     pipelineStatistics = src->pipelineStatistics;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const VkCommandBufferBeginInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
-    flags(in_struct->flags)
+    flags(in_struct->flags),
+    pInheritanceInfo(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pInheritanceInfo)
         pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
-    else
-        pInheritanceInfo = NULL;
 }
 
-safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo()
+safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo() :
+    pNext(nullptr),
+    pInheritanceInfo(nullptr)
 {}
 
 safe_VkCommandBufferBeginInfo::safe_VkCommandBufferBeginInfo(const safe_VkCommandBufferBeginInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pInheritanceInfo)
         pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*src.pInheritanceInfo);
-    else
-        pInheritanceInfo = NULL;
 }
 
 safe_VkCommandBufferBeginInfo& safe_VkCommandBufferBeginInfo::operator=(const safe_VkCommandBufferBeginInfo& src)
@@ -5121,14 +5526,15 @@ safe_VkCommandBufferBeginInfo& safe_VkCommandBufferBeginInfo::operator=(const sa
 
     if (pInheritanceInfo)
         delete pInheritanceInfo;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pInheritanceInfo)
         pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*src.pInheritanceInfo);
-    else
-        pInheritanceInfo = NULL;
 
     return *this;
 }
@@ -5137,85 +5543,89 @@ safe_VkCommandBufferBeginInfo::~safe_VkCommandBufferBeginInfo()
 {
     if (pInheritanceInfo)
         delete pInheritanceInfo;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCommandBufferBeginInfo::initialize(const VkCommandBufferBeginInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pInheritanceInfo)
         pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(in_struct->pInheritanceInfo);
-    else
-        pInheritanceInfo = NULL;
 }
 
 void safe_VkCommandBufferBeginInfo::initialize(const safe_VkCommandBufferBeginInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
+    pInheritanceInfo = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pInheritanceInfo)
         pInheritanceInfo = new safe_VkCommandBufferInheritanceInfo(*src->pInheritanceInfo);
-    else
-        pInheritanceInfo = NULL;
 }
 
 safe_VkMemoryBarrier::safe_VkMemoryBarrier(const VkMemoryBarrier* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     srcAccessMask(in_struct->srcAccessMask),
     dstAccessMask(in_struct->dstAccessMask)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryBarrier::safe_VkMemoryBarrier()
+safe_VkMemoryBarrier::safe_VkMemoryBarrier() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryBarrier::safe_VkMemoryBarrier(const safe_VkMemoryBarrier& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     srcAccessMask = src.srcAccessMask;
     dstAccessMask = src.dstAccessMask;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryBarrier& safe_VkMemoryBarrier::operator=(const safe_VkMemoryBarrier& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     srcAccessMask = src.srcAccessMask;
     dstAccessMask = src.dstAccessMask;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryBarrier::~safe_VkMemoryBarrier()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryBarrier::initialize(const VkMemoryBarrier* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     srcAccessMask = in_struct->srcAccessMask;
     dstAccessMask = in_struct->dstAccessMask;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryBarrier::initialize(const safe_VkMemoryBarrier* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     srcAccessMask = src->srcAccessMask;
     dstAccessMask = src->dstAccessMask;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarrier* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     srcAccessMask(in_struct->srcAccessMask),
     dstAccessMask(in_struct->dstAccessMask),
     srcQueueFamilyIndex(in_struct->srcQueueFamilyIndex),
@@ -5224,15 +5634,16 @@ safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const VkBufferMemoryBarri
     offset(in_struct->offset),
     size(in_struct->size)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier()
+safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier() :
+    pNext(nullptr)
 {}
 
 safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemoryBarrier& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     srcAccessMask = src.srcAccessMask;
     dstAccessMask = src.dstAccessMask;
     srcQueueFamilyIndex = src.srcQueueFamilyIndex;
@@ -5240,15 +5651,17 @@ safe_VkBufferMemoryBarrier::safe_VkBufferMemoryBarrier(const safe_VkBufferMemory
     buffer = src.buffer;
     offset = src.offset;
     size = src.size;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBufferMemoryBarrier& safe_VkBufferMemoryBarrier::operator=(const safe_VkBufferMemoryBarrier& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     srcAccessMask = src.srcAccessMask;
     dstAccessMask = src.dstAccessMask;
     srcQueueFamilyIndex = src.srcQueueFamilyIndex;
@@ -5256,18 +5669,20 @@ safe_VkBufferMemoryBarrier& safe_VkBufferMemoryBarrier::operator=(const safe_VkB
     buffer = src.buffer;
     offset = src.offset;
     size = src.size;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBufferMemoryBarrier::~safe_VkBufferMemoryBarrier()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     srcAccessMask = in_struct->srcAccessMask;
     dstAccessMask = in_struct->dstAccessMask;
     srcQueueFamilyIndex = in_struct->srcQueueFamilyIndex;
@@ -5275,12 +5690,12 @@ void safe_VkBufferMemoryBarrier::initialize(const VkBufferMemoryBarrier* in_stru
     buffer = in_struct->buffer;
     offset = in_struct->offset;
     size = in_struct->size;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     srcAccessMask = src->srcAccessMask;
     dstAccessMask = src->dstAccessMask;
     srcQueueFamilyIndex = src->srcQueueFamilyIndex;
@@ -5288,11 +5703,11 @@ void safe_VkBufferMemoryBarrier::initialize(const safe_VkBufferMemoryBarrier* sr
     buffer = src->buffer;
     offset = src->offset;
     size = src->size;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     srcAccessMask(in_struct->srcAccessMask),
     dstAccessMask(in_struct->dstAccessMask),
     oldLayout(in_struct->oldLayout),
@@ -5302,15 +5717,16 @@ safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const VkImageMemoryBarrier*
     image(in_struct->image),
     subresourceRange(in_struct->subresourceRange)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier()
+safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier() :
+    pNext(nullptr)
 {}
 
 safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBarrier& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     srcAccessMask = src.srcAccessMask;
     dstAccessMask = src.dstAccessMask;
     oldLayout = src.oldLayout;
@@ -5319,15 +5735,17 @@ safe_VkImageMemoryBarrier::safe_VkImageMemoryBarrier(const safe_VkImageMemoryBar
     dstQueueFamilyIndex = src.dstQueueFamilyIndex;
     image = src.image;
     subresourceRange = src.subresourceRange;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageMemoryBarrier& safe_VkImageMemoryBarrier::operator=(const safe_VkImageMemoryBarrier& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     srcAccessMask = src.srcAccessMask;
     dstAccessMask = src.dstAccessMask;
     oldLayout = src.oldLayout;
@@ -5336,18 +5754,20 @@ safe_VkImageMemoryBarrier& safe_VkImageMemoryBarrier::operator=(const safe_VkIma
     dstQueueFamilyIndex = src.dstQueueFamilyIndex;
     image = src.image;
     subresourceRange = src.subresourceRange;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageMemoryBarrier::~safe_VkImageMemoryBarrier()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     srcAccessMask = in_struct->srcAccessMask;
     dstAccessMask = in_struct->dstAccessMask;
     oldLayout = in_struct->oldLayout;
@@ -5356,12 +5776,12 @@ void safe_VkImageMemoryBarrier::initialize(const VkImageMemoryBarrier* in_struct
     dstQueueFamilyIndex = in_struct->dstQueueFamilyIndex;
     image = in_struct->image;
     subresourceRange = in_struct->subresourceRange;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     srcAccessMask = src->srcAccessMask;
     dstAccessMask = src->dstAccessMask;
     oldLayout = src->oldLayout;
@@ -5370,17 +5790,18 @@ void safe_VkImageMemoryBarrier::initialize(const safe_VkImageMemoryBarrier* src)
     dstQueueFamilyIndex = src->dstQueueFamilyIndex;
     image = src->image;
     subresourceRange = src->subresourceRange;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const VkRenderPassBeginInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     renderPass(in_struct->renderPass),
     framebuffer(in_struct->framebuffer),
     renderArea(in_struct->renderArea),
     clearValueCount(in_struct->clearValueCount),
     pClearValues(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pClearValues) {
         pClearValues = new VkClearValue[in_struct->clearValueCount];
         memcpy ((void *)pClearValues, (void *)in_struct->pClearValues, sizeof(VkClearValue)*in_struct->clearValueCount);
@@ -5388,18 +5809,19 @@ safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const VkRenderPassBeginIn
 }
 
 safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo() :
+    pNext(nullptr),
     pClearValues(nullptr)
 {}
 
 safe_VkRenderPassBeginInfo::safe_VkRenderPassBeginInfo(const safe_VkRenderPassBeginInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     renderPass = src.renderPass;
     framebuffer = src.framebuffer;
     renderArea = src.renderArea;
     clearValueCount = src.clearValueCount;
     pClearValues = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pClearValues) {
         pClearValues = new VkClearValue[src.clearValueCount];
         memcpy ((void *)pClearValues, (void *)src.pClearValues, sizeof(VkClearValue)*src.clearValueCount);
@@ -5412,14 +5834,16 @@ safe_VkRenderPassBeginInfo& safe_VkRenderPassBeginInfo::operator=(const safe_VkR
 
     if (pClearValues)
         delete[] pClearValues;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     renderPass = src.renderPass;
     framebuffer = src.framebuffer;
     renderArea = src.renderArea;
     clearValueCount = src.clearValueCount;
     pClearValues = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pClearValues) {
         pClearValues = new VkClearValue[src.clearValueCount];
         memcpy ((void *)pClearValues, (void *)src.pClearValues, sizeof(VkClearValue)*src.clearValueCount);
@@ -5432,17 +5856,19 @@ safe_VkRenderPassBeginInfo::~safe_VkRenderPassBeginInfo()
 {
     if (pClearValues)
         delete[] pClearValues;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassBeginInfo::initialize(const VkRenderPassBeginInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     renderPass = in_struct->renderPass;
     framebuffer = in_struct->framebuffer;
     renderArea = in_struct->renderArea;
     clearValueCount = in_struct->clearValueCount;
     pClearValues = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pClearValues) {
         pClearValues = new VkClearValue[in_struct->clearValueCount];
         memcpy ((void *)pClearValues, (void *)in_struct->pClearValues, sizeof(VkClearValue)*in_struct->clearValueCount);
@@ -5452,541 +5878,454 @@ void safe_VkRenderPassBeginInfo::initialize(const VkRenderPassBeginInfo* in_stru
 void safe_VkRenderPassBeginInfo::initialize(const safe_VkRenderPassBeginInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     renderPass = src->renderPass;
     framebuffer = src->framebuffer;
     renderArea = src->renderArea;
     clearValueCount = src->clearValueCount;
     pClearValues = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pClearValues) {
         pClearValues = new VkClearValue[src->clearValueCount];
         memcpy ((void *)pClearValues, (void *)src->pClearValues, sizeof(VkClearValue)*src->clearValueCount);
     }
 }
 
-safe_VkBaseOutStructure::safe_VkBaseOutStructure(const VkBaseOutStructure* in_struct) :
-    sType(in_struct->sType)
-{
-    if (in_struct->pNext)
-        pNext = new safe_VkBaseOutStructure(in_struct->pNext);
-    else
-        pNext = NULL;
-}
-
-safe_VkBaseOutStructure::safe_VkBaseOutStructure()
-{}
-
-safe_VkBaseOutStructure::safe_VkBaseOutStructure(const safe_VkBaseOutStructure& src)
-{
-    sType = src.sType;
-    if (src.pNext)
-        pNext = new safe_VkBaseOutStructure(*src.pNext);
-    else
-        pNext = NULL;
-}
-
-safe_VkBaseOutStructure& safe_VkBaseOutStructure::operator=(const safe_VkBaseOutStructure& src)
-{
-    if (&src == this) return *this;
-
-    if (pNext)
-        delete pNext;
-
-    sType = src.sType;
-    if (src.pNext)
-        pNext = new safe_VkBaseOutStructure(*src.pNext);
-    else
-        pNext = NULL;
-
-    return *this;
-}
-
-safe_VkBaseOutStructure::~safe_VkBaseOutStructure()
-{
-    if (pNext)
-        delete pNext;
-}
-
-void safe_VkBaseOutStructure::initialize(const VkBaseOutStructure* in_struct)
-{
-    sType = in_struct->sType;
-    if (in_struct->pNext)
-        pNext = new safe_VkBaseOutStructure(in_struct->pNext);
-    else
-        pNext = NULL;
-}
-
-void safe_VkBaseOutStructure::initialize(const safe_VkBaseOutStructure* src)
-{
-    sType = src->sType;
-    if (src->pNext)
-        pNext = new safe_VkBaseOutStructure(*src->pNext);
-    else
-        pNext = NULL;
-}
-
-safe_VkBaseInStructure::safe_VkBaseInStructure(const VkBaseInStructure* in_struct) :
-    sType(in_struct->sType)
-{
-    if (in_struct->pNext)
-        pNext = new safe_VkBaseInStructure(in_struct->pNext);
-    else
-        pNext = NULL;
-}
-
-safe_VkBaseInStructure::safe_VkBaseInStructure()
-{}
-
-safe_VkBaseInStructure::safe_VkBaseInStructure(const safe_VkBaseInStructure& src)
-{
-    sType = src.sType;
-    if (src.pNext)
-        pNext = new safe_VkBaseInStructure(*src.pNext);
-    else
-        pNext = NULL;
-}
-
-safe_VkBaseInStructure& safe_VkBaseInStructure::operator=(const safe_VkBaseInStructure& src)
-{
-    if (&src == this) return *this;
-
-    if (pNext)
-        delete pNext;
-
-    sType = src.sType;
-    if (src.pNext)
-        pNext = new safe_VkBaseInStructure(*src.pNext);
-    else
-        pNext = NULL;
-
-    return *this;
-}
-
-safe_VkBaseInStructure::~safe_VkBaseInStructure()
-{
-    if (pNext)
-        delete pNext;
-}
-
-void safe_VkBaseInStructure::initialize(const VkBaseInStructure* in_struct)
-{
-    sType = in_struct->sType;
-    if (in_struct->pNext)
-        pNext = new safe_VkBaseInStructure(in_struct->pNext);
-    else
-        pNext = NULL;
-}
-
-void safe_VkBaseInStructure::initialize(const safe_VkBaseInStructure* src)
-{
-    sType = src->sType;
-    if (src->pNext)
-        pNext = new safe_VkBaseInStructure(*src->pNext);
-    else
-        pNext = NULL;
-}
-
 safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties(const VkPhysicalDeviceSubgroupProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     subgroupSize(in_struct->subgroupSize),
     supportedStages(in_struct->supportedStages),
     supportedOperations(in_struct->supportedOperations),
     quadOperationsInAllStages(in_struct->quadOperationsInAllStages)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties()
+safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceSubgroupProperties::safe_VkPhysicalDeviceSubgroupProperties(const safe_VkPhysicalDeviceSubgroupProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     subgroupSize = src.subgroupSize;
     supportedStages = src.supportedStages;
     supportedOperations = src.supportedOperations;
     quadOperationsInAllStages = src.quadOperationsInAllStages;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceSubgroupProperties& safe_VkPhysicalDeviceSubgroupProperties::operator=(const safe_VkPhysicalDeviceSubgroupProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     subgroupSize = src.subgroupSize;
     supportedStages = src.supportedStages;
     supportedOperations = src.supportedOperations;
     quadOperationsInAllStages = src.quadOperationsInAllStages;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceSubgroupProperties::~safe_VkPhysicalDeviceSubgroupProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceSubgroupProperties::initialize(const VkPhysicalDeviceSubgroupProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     subgroupSize = in_struct->subgroupSize;
     supportedStages = in_struct->supportedStages;
     supportedOperations = in_struct->supportedOperations;
     quadOperationsInAllStages = in_struct->quadOperationsInAllStages;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceSubgroupProperties::initialize(const safe_VkPhysicalDeviceSubgroupProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     subgroupSize = src->subgroupSize;
     supportedStages = src->supportedStages;
     supportedOperations = src->supportedOperations;
     quadOperationsInAllStages = src->quadOperationsInAllStages;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const VkBindBufferMemoryInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     buffer(in_struct->buffer),
     memory(in_struct->memory),
     memoryOffset(in_struct->memoryOffset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo()
+safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkBindBufferMemoryInfo::safe_VkBindBufferMemoryInfo(const safe_VkBindBufferMemoryInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
     memory = src.memory;
     memoryOffset = src.memoryOffset;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBindBufferMemoryInfo& safe_VkBindBufferMemoryInfo::operator=(const safe_VkBindBufferMemoryInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
     memory = src.memory;
     memoryOffset = src.memoryOffset;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBindBufferMemoryInfo::~safe_VkBindBufferMemoryInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindBufferMemoryInfo::initialize(const VkBindBufferMemoryInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     buffer = in_struct->buffer;
     memory = in_struct->memory;
     memoryOffset = in_struct->memoryOffset;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBindBufferMemoryInfo::initialize(const safe_VkBindBufferMemoryInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     buffer = src->buffer;
     memory = src->memory;
     memoryOffset = src->memoryOffset;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const VkBindImageMemoryInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     image(in_struct->image),
     memory(in_struct->memory),
     memoryOffset(in_struct->memoryOffset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo()
+safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkBindImageMemoryInfo::safe_VkBindImageMemoryInfo(const safe_VkBindImageMemoryInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
     memory = src.memory;
     memoryOffset = src.memoryOffset;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBindImageMemoryInfo& safe_VkBindImageMemoryInfo::operator=(const safe_VkBindImageMemoryInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
     memory = src.memory;
     memoryOffset = src.memoryOffset;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBindImageMemoryInfo::~safe_VkBindImageMemoryInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindImageMemoryInfo::initialize(const VkBindImageMemoryInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     image = in_struct->image;
     memory = in_struct->memory;
     memoryOffset = in_struct->memoryOffset;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBindImageMemoryInfo::initialize(const safe_VkBindImageMemoryInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     image = src->image;
     memory = src->memory;
     memoryOffset = src->memoryOffset;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures(const VkPhysicalDevice16BitStorageFeatures* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     storageBuffer16BitAccess(in_struct->storageBuffer16BitAccess),
     uniformAndStorageBuffer16BitAccess(in_struct->uniformAndStorageBuffer16BitAccess),
     storagePushConstant16(in_struct->storagePushConstant16),
     storageInputOutput16(in_struct->storageInputOutput16)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures()
+safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDevice16BitStorageFeatures::safe_VkPhysicalDevice16BitStorageFeatures(const safe_VkPhysicalDevice16BitStorageFeatures& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     storageBuffer16BitAccess = src.storageBuffer16BitAccess;
     uniformAndStorageBuffer16BitAccess = src.uniformAndStorageBuffer16BitAccess;
     storagePushConstant16 = src.storagePushConstant16;
     storageInputOutput16 = src.storageInputOutput16;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDevice16BitStorageFeatures& safe_VkPhysicalDevice16BitStorageFeatures::operator=(const safe_VkPhysicalDevice16BitStorageFeatures& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     storageBuffer16BitAccess = src.storageBuffer16BitAccess;
     uniformAndStorageBuffer16BitAccess = src.uniformAndStorageBuffer16BitAccess;
     storagePushConstant16 = src.storagePushConstant16;
     storageInputOutput16 = src.storageInputOutput16;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDevice16BitStorageFeatures::~safe_VkPhysicalDevice16BitStorageFeatures()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const VkPhysicalDevice16BitStorageFeatures* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     storageBuffer16BitAccess = in_struct->storageBuffer16BitAccess;
     uniformAndStorageBuffer16BitAccess = in_struct->uniformAndStorageBuffer16BitAccess;
     storagePushConstant16 = in_struct->storagePushConstant16;
     storageInputOutput16 = in_struct->storageInputOutput16;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDevice16BitStorageFeatures::initialize(const safe_VkPhysicalDevice16BitStorageFeatures* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     storageBuffer16BitAccess = src->storageBuffer16BitAccess;
     uniformAndStorageBuffer16BitAccess = src->uniformAndStorageBuffer16BitAccess;
     storagePushConstant16 = src->storagePushConstant16;
     storageInputOutput16 = src->storageInputOutput16;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const VkMemoryDedicatedRequirements* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     prefersDedicatedAllocation(in_struct->prefersDedicatedAllocation),
     requiresDedicatedAllocation(in_struct->requiresDedicatedAllocation)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements()
+safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryDedicatedRequirements::safe_VkMemoryDedicatedRequirements(const safe_VkMemoryDedicatedRequirements& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     prefersDedicatedAllocation = src.prefersDedicatedAllocation;
     requiresDedicatedAllocation = src.requiresDedicatedAllocation;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryDedicatedRequirements& safe_VkMemoryDedicatedRequirements::operator=(const safe_VkMemoryDedicatedRequirements& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     prefersDedicatedAllocation = src.prefersDedicatedAllocation;
     requiresDedicatedAllocation = src.requiresDedicatedAllocation;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryDedicatedRequirements::~safe_VkMemoryDedicatedRequirements()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryDedicatedRequirements::initialize(const VkMemoryDedicatedRequirements* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     prefersDedicatedAllocation = in_struct->prefersDedicatedAllocation;
     requiresDedicatedAllocation = in_struct->requiresDedicatedAllocation;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryDedicatedRequirements::initialize(const safe_VkMemoryDedicatedRequirements* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     prefersDedicatedAllocation = src->prefersDedicatedAllocation;
     requiresDedicatedAllocation = src->requiresDedicatedAllocation;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const VkMemoryDedicatedAllocateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     image(in_struct->image),
     buffer(in_struct->buffer)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo()
+safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryDedicatedAllocateInfo::safe_VkMemoryDedicatedAllocateInfo(const safe_VkMemoryDedicatedAllocateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryDedicatedAllocateInfo& safe_VkMemoryDedicatedAllocateInfo::operator=(const safe_VkMemoryDedicatedAllocateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryDedicatedAllocateInfo::~safe_VkMemoryDedicatedAllocateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryDedicatedAllocateInfo::initialize(const VkMemoryDedicatedAllocateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     image = in_struct->image;
     buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryDedicatedAllocateInfo::initialize(const safe_VkMemoryDedicatedAllocateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     image = src->image;
     buffer = src->buffer;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const VkMemoryAllocateFlagsInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     deviceMask(in_struct->deviceMask)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo()
+safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryAllocateFlagsInfo::safe_VkMemoryAllocateFlagsInfo(const safe_VkMemoryAllocateFlagsInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     deviceMask = src.deviceMask;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryAllocateFlagsInfo& safe_VkMemoryAllocateFlagsInfo::operator=(const safe_VkMemoryAllocateFlagsInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     deviceMask = src.deviceMask;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryAllocateFlagsInfo::~safe_VkMemoryAllocateFlagsInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryAllocateFlagsInfo::initialize(const VkMemoryAllocateFlagsInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     deviceMask = in_struct->deviceMask;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryAllocateFlagsInfo::initialize(const safe_VkMemoryAllocateFlagsInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     deviceMask = src->deviceMask;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(const VkDeviceGroupRenderPassBeginInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     deviceMask(in_struct->deviceMask),
     deviceRenderAreaCount(in_struct->deviceRenderAreaCount),
     pDeviceRenderAreas(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceRenderAreas) {
         pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
         memcpy ((void *)pDeviceRenderAreas, (void *)in_struct->pDeviceRenderAreas, sizeof(VkRect2D)*in_struct->deviceRenderAreaCount);
@@ -5994,16 +6333,17 @@ safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(con
 }
 
 safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo() :
+    pNext(nullptr),
     pDeviceRenderAreas(nullptr)
 {}
 
 safe_VkDeviceGroupRenderPassBeginInfo::safe_VkDeviceGroupRenderPassBeginInfo(const safe_VkDeviceGroupRenderPassBeginInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     deviceMask = src.deviceMask;
     deviceRenderAreaCount = src.deviceRenderAreaCount;
     pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceRenderAreas) {
         pDeviceRenderAreas = new VkRect2D[src.deviceRenderAreaCount];
         memcpy ((void *)pDeviceRenderAreas, (void *)src.pDeviceRenderAreas, sizeof(VkRect2D)*src.deviceRenderAreaCount);
@@ -6016,12 +6356,14 @@ safe_VkDeviceGroupRenderPassBeginInfo& safe_VkDeviceGroupRenderPassBeginInfo::op
 
     if (pDeviceRenderAreas)
         delete[] pDeviceRenderAreas;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     deviceMask = src.deviceMask;
     deviceRenderAreaCount = src.deviceRenderAreaCount;
     pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceRenderAreas) {
         pDeviceRenderAreas = new VkRect2D[src.deviceRenderAreaCount];
         memcpy ((void *)pDeviceRenderAreas, (void *)src.pDeviceRenderAreas, sizeof(VkRect2D)*src.deviceRenderAreaCount);
@@ -6034,15 +6376,17 @@ safe_VkDeviceGroupRenderPassBeginInfo::~safe_VkDeviceGroupRenderPassBeginInfo()
 {
     if (pDeviceRenderAreas)
         delete[] pDeviceRenderAreas;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const VkDeviceGroupRenderPassBeginInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     deviceMask = in_struct->deviceMask;
     deviceRenderAreaCount = in_struct->deviceRenderAreaCount;
     pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceRenderAreas) {
         pDeviceRenderAreas = new VkRect2D[in_struct->deviceRenderAreaCount];
         memcpy ((void *)pDeviceRenderAreas, (void *)in_struct->pDeviceRenderAreas, sizeof(VkRect2D)*in_struct->deviceRenderAreaCount);
@@ -6052,10 +6396,10 @@ void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const VkDeviceGroupRender
 void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const safe_VkDeviceGroupRenderPassBeginInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     deviceMask = src->deviceMask;
     deviceRenderAreaCount = src->deviceRenderAreaCount;
     pDeviceRenderAreas = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDeviceRenderAreas) {
         pDeviceRenderAreas = new VkRect2D[src->deviceRenderAreaCount];
         memcpy ((void *)pDeviceRenderAreas, (void *)src->pDeviceRenderAreas, sizeof(VkRect2D)*src->deviceRenderAreaCount);
@@ -6064,54 +6408,58 @@ void safe_VkDeviceGroupRenderPassBeginInfo::initialize(const safe_VkDeviceGroupR
 
 safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo(const VkDeviceGroupCommandBufferBeginInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     deviceMask(in_struct->deviceMask)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo()
+safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceGroupCommandBufferBeginInfo::safe_VkDeviceGroupCommandBufferBeginInfo(const safe_VkDeviceGroupCommandBufferBeginInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     deviceMask = src.deviceMask;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceGroupCommandBufferBeginInfo& safe_VkDeviceGroupCommandBufferBeginInfo::operator=(const safe_VkDeviceGroupCommandBufferBeginInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     deviceMask = src.deviceMask;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceGroupCommandBufferBeginInfo::~safe_VkDeviceGroupCommandBufferBeginInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const VkDeviceGroupCommandBufferBeginInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     deviceMask = in_struct->deviceMask;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceGroupCommandBufferBeginInfo::initialize(const safe_VkDeviceGroupCommandBufferBeginInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     deviceMask = src->deviceMask;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSubmitInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     waitSemaphoreCount(in_struct->waitSemaphoreCount),
     pWaitSemaphoreDeviceIndices(nullptr),
     commandBufferCount(in_struct->commandBufferCount),
@@ -6119,6 +6467,7 @@ safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSu
     signalSemaphoreCount(in_struct->signalSemaphoreCount),
     pSignalSemaphoreDeviceIndices(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pWaitSemaphoreDeviceIndices) {
         pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
         memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)in_struct->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->waitSemaphoreCount);
@@ -6134,6 +6483,7 @@ safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const VkDeviceGroupSu
 }
 
 safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo() :
+    pNext(nullptr),
     pWaitSemaphoreDeviceIndices(nullptr),
     pCommandBufferDeviceMasks(nullptr),
     pSignalSemaphoreDeviceIndices(nullptr)
@@ -6142,13 +6492,13 @@ safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo() :
 safe_VkDeviceGroupSubmitInfo::safe_VkDeviceGroupSubmitInfo(const safe_VkDeviceGroupSubmitInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphoreDeviceIndices = nullptr;
     commandBufferCount = src.commandBufferCount;
     pCommandBufferDeviceMasks = nullptr;
     signalSemaphoreCount = src.signalSemaphoreCount;
     pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pWaitSemaphoreDeviceIndices) {
         pWaitSemaphoreDeviceIndices = new uint32_t[src.waitSemaphoreCount];
         memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)src.pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*src.waitSemaphoreCount);
@@ -6173,15 +6523,17 @@ safe_VkDeviceGroupSubmitInfo& safe_VkDeviceGroupSubmitInfo::operator=(const safe
         delete[] pCommandBufferDeviceMasks;
     if (pSignalSemaphoreDeviceIndices)
         delete[] pSignalSemaphoreDeviceIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphoreDeviceIndices = nullptr;
     commandBufferCount = src.commandBufferCount;
     pCommandBufferDeviceMasks = nullptr;
     signalSemaphoreCount = src.signalSemaphoreCount;
     pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pWaitSemaphoreDeviceIndices) {
         pWaitSemaphoreDeviceIndices = new uint32_t[src.waitSemaphoreCount];
         memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)src.pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*src.waitSemaphoreCount);
@@ -6206,18 +6558,20 @@ safe_VkDeviceGroupSubmitInfo::~safe_VkDeviceGroupSubmitInfo()
         delete[] pCommandBufferDeviceMasks;
     if (pSignalSemaphoreDeviceIndices)
         delete[] pSignalSemaphoreDeviceIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupSubmitInfo::initialize(const VkDeviceGroupSubmitInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     waitSemaphoreCount = in_struct->waitSemaphoreCount;
     pWaitSemaphoreDeviceIndices = nullptr;
     commandBufferCount = in_struct->commandBufferCount;
     pCommandBufferDeviceMasks = nullptr;
     signalSemaphoreCount = in_struct->signalSemaphoreCount;
     pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pWaitSemaphoreDeviceIndices) {
         pWaitSemaphoreDeviceIndices = new uint32_t[in_struct->waitSemaphoreCount];
         memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)in_struct->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*in_struct->waitSemaphoreCount);
@@ -6235,13 +6589,13 @@ void safe_VkDeviceGroupSubmitInfo::initialize(const VkDeviceGroupSubmitInfo* in_
 void safe_VkDeviceGroupSubmitInfo::initialize(const safe_VkDeviceGroupSubmitInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     waitSemaphoreCount = src->waitSemaphoreCount;
     pWaitSemaphoreDeviceIndices = nullptr;
     commandBufferCount = src->commandBufferCount;
     pCommandBufferDeviceMasks = nullptr;
     signalSemaphoreCount = src->signalSemaphoreCount;
     pSignalSemaphoreDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pWaitSemaphoreDeviceIndices) {
         pWaitSemaphoreDeviceIndices = new uint32_t[src->waitSemaphoreCount];
         memcpy ((void *)pWaitSemaphoreDeviceIndices, (void *)src->pWaitSemaphoreDeviceIndices, sizeof(uint32_t)*src->waitSemaphoreCount);
@@ -6258,62 +6612,67 @@ void safe_VkDeviceGroupSubmitInfo::initialize(const safe_VkDeviceGroupSubmitInfo
 
 safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const VkDeviceGroupBindSparseInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     resourceDeviceIndex(in_struct->resourceDeviceIndex),
     memoryDeviceIndex(in_struct->memoryDeviceIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo()
+safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceGroupBindSparseInfo::safe_VkDeviceGroupBindSparseInfo(const safe_VkDeviceGroupBindSparseInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     resourceDeviceIndex = src.resourceDeviceIndex;
     memoryDeviceIndex = src.memoryDeviceIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceGroupBindSparseInfo& safe_VkDeviceGroupBindSparseInfo::operator=(const safe_VkDeviceGroupBindSparseInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     resourceDeviceIndex = src.resourceDeviceIndex;
     memoryDeviceIndex = src.memoryDeviceIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceGroupBindSparseInfo::~safe_VkDeviceGroupBindSparseInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupBindSparseInfo::initialize(const VkDeviceGroupBindSparseInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     resourceDeviceIndex = in_struct->resourceDeviceIndex;
     memoryDeviceIndex = in_struct->memoryDeviceIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceGroupBindSparseInfo::initialize(const safe_VkDeviceGroupBindSparseInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     resourceDeviceIndex = src->resourceDeviceIndex;
     memoryDeviceIndex = src->memoryDeviceIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(const VkBindBufferMemoryDeviceGroupInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     deviceIndexCount(in_struct->deviceIndexCount),
     pDeviceIndices(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceIndices) {
         pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
@@ -6321,15 +6680,16 @@ safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(c
 }
 
 safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo() :
+    pNext(nullptr),
     pDeviceIndices(nullptr)
 {}
 
 safe_VkBindBufferMemoryDeviceGroupInfo::safe_VkBindBufferMemoryDeviceGroupInfo(const safe_VkBindBufferMemoryDeviceGroupInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     deviceIndexCount = src.deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceIndices) {
         pDeviceIndices = new uint32_t[src.deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
@@ -6342,11 +6702,13 @@ safe_VkBindBufferMemoryDeviceGroupInfo& safe_VkBindBufferMemoryDeviceGroupInfo::
 
     if (pDeviceIndices)
         delete[] pDeviceIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     deviceIndexCount = src.deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceIndices) {
         pDeviceIndices = new uint32_t[src.deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
@@ -6359,14 +6721,16 @@ safe_VkBindBufferMemoryDeviceGroupInfo::~safe_VkBindBufferMemoryDeviceGroupInfo(
 {
     if (pDeviceIndices)
         delete[] pDeviceIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const VkBindBufferMemoryDeviceGroupInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     deviceIndexCount = in_struct->deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceIndices) {
         pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
@@ -6376,9 +6740,9 @@ void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const VkBindBufferMemory
 void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const safe_VkBindBufferMemoryDeviceGroupInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     deviceIndexCount = src->deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDeviceIndices) {
         pDeviceIndices = new uint32_t[src->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src->pDeviceIndices, sizeof(uint32_t)*src->deviceIndexCount);
@@ -6387,12 +6751,12 @@ void safe_VkBindBufferMemoryDeviceGroupInfo::initialize(const safe_VkBindBufferM
 
 safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(const VkBindImageMemoryDeviceGroupInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     deviceIndexCount(in_struct->deviceIndexCount),
     pDeviceIndices(nullptr),
     splitInstanceBindRegionCount(in_struct->splitInstanceBindRegionCount),
     pSplitInstanceBindRegions(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceIndices) {
         pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
@@ -6404,6 +6768,7 @@ safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(con
 }
 
 safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo() :
+    pNext(nullptr),
     pDeviceIndices(nullptr),
     pSplitInstanceBindRegions(nullptr)
 {}
@@ -6411,11 +6776,11 @@ safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo() :
 safe_VkBindImageMemoryDeviceGroupInfo::safe_VkBindImageMemoryDeviceGroupInfo(const safe_VkBindImageMemoryDeviceGroupInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     deviceIndexCount = src.deviceIndexCount;
     pDeviceIndices = nullptr;
     splitInstanceBindRegionCount = src.splitInstanceBindRegionCount;
     pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceIndices) {
         pDeviceIndices = new uint32_t[src.deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
@@ -6434,13 +6799,15 @@ safe_VkBindImageMemoryDeviceGroupInfo& safe_VkBindImageMemoryDeviceGroupInfo::op
         delete[] pDeviceIndices;
     if (pSplitInstanceBindRegions)
         delete[] pSplitInstanceBindRegions;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     deviceIndexCount = src.deviceIndexCount;
     pDeviceIndices = nullptr;
     splitInstanceBindRegionCount = src.splitInstanceBindRegionCount;
     pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceIndices) {
         pDeviceIndices = new uint32_t[src.deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
@@ -6459,16 +6826,18 @@ safe_VkBindImageMemoryDeviceGroupInfo::~safe_VkBindImageMemoryDeviceGroupInfo()
         delete[] pDeviceIndices;
     if (pSplitInstanceBindRegions)
         delete[] pSplitInstanceBindRegions;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const VkBindImageMemoryDeviceGroupInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     deviceIndexCount = in_struct->deviceIndexCount;
     pDeviceIndices = nullptr;
     splitInstanceBindRegionCount = in_struct->splitInstanceBindRegionCount;
     pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceIndices) {
         pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
@@ -6482,11 +6851,11 @@ void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const VkBindImageMemoryDe
 void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const safe_VkBindImageMemoryDeviceGroupInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     deviceIndexCount = src->deviceIndexCount;
     pDeviceIndices = nullptr;
     splitInstanceBindRegionCount = src->splitInstanceBindRegionCount;
     pSplitInstanceBindRegions = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDeviceIndices) {
         pDeviceIndices = new uint32_t[src->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src->pDeviceIndices, sizeof(uint32_t)*src->deviceIndexCount);
@@ -6499,25 +6868,26 @@ void safe_VkBindImageMemoryDeviceGroupInfo::initialize(const safe_VkBindImageMem
 
 safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const VkPhysicalDeviceGroupProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     physicalDeviceCount(in_struct->physicalDeviceCount),
     subsetAllocation(in_struct->subsetAllocation)
 {
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         physicalDevices[i] = in_struct->physicalDevices[i];
     }
 }
 
-safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties()
+safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceGroupProperties::safe_VkPhysicalDeviceGroupProperties(const safe_VkPhysicalDeviceGroupProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     physicalDeviceCount = src.physicalDeviceCount;
     subsetAllocation = src.subsetAllocation;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         physicalDevices[i] = src.physicalDevices[i];
     }
 }
@@ -6526,12 +6896,14 @@ safe_VkPhysicalDeviceGroupProperties& safe_VkPhysicalDeviceGroupProperties::oper
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     physicalDeviceCount = src.physicalDeviceCount;
     subsetAllocation = src.subsetAllocation;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         physicalDevices[i] = src.physicalDevices[i];
     }
 
@@ -6540,15 +6912,17 @@ safe_VkPhysicalDeviceGroupProperties& safe_VkPhysicalDeviceGroupProperties::oper
 
 safe_VkPhysicalDeviceGroupProperties::~safe_VkPhysicalDeviceGroupProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceGroupProperties::initialize(const VkPhysicalDeviceGroupProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     physicalDeviceCount = in_struct->physicalDeviceCount;
     subsetAllocation = in_struct->subsetAllocation;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         physicalDevices[i] = in_struct->physicalDevices[i];
     }
 }
@@ -6556,20 +6930,20 @@ void safe_VkPhysicalDeviceGroupProperties::initialize(const VkPhysicalDeviceGrou
 void safe_VkPhysicalDeviceGroupProperties::initialize(const safe_VkPhysicalDeviceGroupProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     physicalDeviceCount = src->physicalDeviceCount;
     subsetAllocation = src->subsetAllocation;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         physicalDevices[i] = src->physicalDevices[i];
     }
 }
 
 safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const VkDeviceGroupDeviceCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     physicalDeviceCount(in_struct->physicalDeviceCount),
     pPhysicalDevices(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPhysicalDevices) {
         pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
         memcpy ((void *)pPhysicalDevices, (void *)in_struct->pPhysicalDevices, sizeof(VkPhysicalDevice)*in_struct->physicalDeviceCount);
@@ -6577,15 +6951,16 @@ safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const VkD
 }
 
 safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo() :
+    pNext(nullptr),
     pPhysicalDevices(nullptr)
 {}
 
 safe_VkDeviceGroupDeviceCreateInfo::safe_VkDeviceGroupDeviceCreateInfo(const safe_VkDeviceGroupDeviceCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     physicalDeviceCount = src.physicalDeviceCount;
     pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPhysicalDevices) {
         pPhysicalDevices = new VkPhysicalDevice[src.physicalDeviceCount];
         memcpy ((void *)pPhysicalDevices, (void *)src.pPhysicalDevices, sizeof(VkPhysicalDevice)*src.physicalDeviceCount);
@@ -6598,11 +6973,13 @@ safe_VkDeviceGroupDeviceCreateInfo& safe_VkDeviceGroupDeviceCreateInfo::operator
 
     if (pPhysicalDevices)
         delete[] pPhysicalDevices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     physicalDeviceCount = src.physicalDeviceCount;
     pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPhysicalDevices) {
         pPhysicalDevices = new VkPhysicalDevice[src.physicalDeviceCount];
         memcpy ((void *)pPhysicalDevices, (void *)src.pPhysicalDevices, sizeof(VkPhysicalDevice)*src.physicalDeviceCount);
@@ -6615,14 +6992,16 @@ safe_VkDeviceGroupDeviceCreateInfo::~safe_VkDeviceGroupDeviceCreateInfo()
 {
     if (pPhysicalDevices)
         delete[] pPhysicalDevices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupDeviceCreateInfo::initialize(const VkDeviceGroupDeviceCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     physicalDeviceCount = in_struct->physicalDeviceCount;
     pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPhysicalDevices) {
         pPhysicalDevices = new VkPhysicalDevice[in_struct->physicalDeviceCount];
         memcpy ((void *)pPhysicalDevices, (void *)in_struct->pPhysicalDevices, sizeof(VkPhysicalDevice)*in_struct->physicalDeviceCount);
@@ -6632,9 +7011,9 @@ void safe_VkDeviceGroupDeviceCreateInfo::initialize(const VkDeviceGroupDeviceCre
 void safe_VkDeviceGroupDeviceCreateInfo::initialize(const safe_VkDeviceGroupDeviceCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     physicalDeviceCount = src->physicalDeviceCount;
     pPhysicalDevices = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pPhysicalDevices) {
         pPhysicalDevices = new VkPhysicalDevice[src->physicalDeviceCount];
         memcpy ((void *)pPhysicalDevices, (void *)src->pPhysicalDevices, sizeof(VkPhysicalDevice)*src->physicalDeviceCount);
@@ -6643,755 +7022,830 @@ void safe_VkDeviceGroupDeviceCreateInfo::initialize(const safe_VkDeviceGroupDevi
 
 safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const VkBufferMemoryRequirementsInfo2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     buffer(in_struct->buffer)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2()
+safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2() :
+    pNext(nullptr)
 {}
 
 safe_VkBufferMemoryRequirementsInfo2::safe_VkBufferMemoryRequirementsInfo2(const safe_VkBufferMemoryRequirementsInfo2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBufferMemoryRequirementsInfo2& safe_VkBufferMemoryRequirementsInfo2::operator=(const safe_VkBufferMemoryRequirementsInfo2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBufferMemoryRequirementsInfo2::~safe_VkBufferMemoryRequirementsInfo2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBufferMemoryRequirementsInfo2::initialize(const VkBufferMemoryRequirementsInfo2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBufferMemoryRequirementsInfo2::initialize(const safe_VkBufferMemoryRequirementsInfo2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     buffer = src->buffer;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const VkImageMemoryRequirementsInfo2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     image(in_struct->image)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2()
+safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2() :
+    pNext(nullptr)
 {}
 
 safe_VkImageMemoryRequirementsInfo2::safe_VkImageMemoryRequirementsInfo2(const safe_VkImageMemoryRequirementsInfo2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageMemoryRequirementsInfo2& safe_VkImageMemoryRequirementsInfo2::operator=(const safe_VkImageMemoryRequirementsInfo2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageMemoryRequirementsInfo2::~safe_VkImageMemoryRequirementsInfo2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageMemoryRequirementsInfo2::initialize(const VkImageMemoryRequirementsInfo2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     image = in_struct->image;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageMemoryRequirementsInfo2::initialize(const safe_VkImageMemoryRequirementsInfo2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     image = src->image;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2(const VkImageSparseMemoryRequirementsInfo2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     image(in_struct->image)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2()
+safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2() :
+    pNext(nullptr)
 {}
 
 safe_VkImageSparseMemoryRequirementsInfo2::safe_VkImageSparseMemoryRequirementsInfo2(const safe_VkImageSparseMemoryRequirementsInfo2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageSparseMemoryRequirementsInfo2& safe_VkImageSparseMemoryRequirementsInfo2::operator=(const safe_VkImageSparseMemoryRequirementsInfo2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageSparseMemoryRequirementsInfo2::~safe_VkImageSparseMemoryRequirementsInfo2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const VkImageSparseMemoryRequirementsInfo2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     image = in_struct->image;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageSparseMemoryRequirementsInfo2::initialize(const safe_VkImageSparseMemoryRequirementsInfo2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     image = src->image;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const VkMemoryRequirements2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memoryRequirements(in_struct->memoryRequirements)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryRequirements2::safe_VkMemoryRequirements2()
+safe_VkMemoryRequirements2::safe_VkMemoryRequirements2() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryRequirements2::safe_VkMemoryRequirements2(const safe_VkMemoryRequirements2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memoryRequirements = src.memoryRequirements;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryRequirements2& safe_VkMemoryRequirements2::operator=(const safe_VkMemoryRequirements2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memoryRequirements = src.memoryRequirements;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryRequirements2::~safe_VkMemoryRequirements2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryRequirements2::initialize(const VkMemoryRequirements2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memoryRequirements = in_struct->memoryRequirements;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryRequirements2::initialize(const safe_VkMemoryRequirements2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memoryRequirements = src->memoryRequirements;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2(const VkSparseImageMemoryRequirements2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memoryRequirements(in_struct->memoryRequirements)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2()
+safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2() :
+    pNext(nullptr)
 {}
 
 safe_VkSparseImageMemoryRequirements2::safe_VkSparseImageMemoryRequirements2(const safe_VkSparseImageMemoryRequirements2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memoryRequirements = src.memoryRequirements;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSparseImageMemoryRequirements2& safe_VkSparseImageMemoryRequirements2::operator=(const safe_VkSparseImageMemoryRequirements2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memoryRequirements = src.memoryRequirements;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSparseImageMemoryRequirements2::~safe_VkSparseImageMemoryRequirements2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSparseImageMemoryRequirements2::initialize(const VkSparseImageMemoryRequirements2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memoryRequirements = in_struct->memoryRequirements;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSparseImageMemoryRequirements2::initialize(const safe_VkSparseImageMemoryRequirements2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memoryRequirements = src->memoryRequirements;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const VkPhysicalDeviceFeatures2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     features(in_struct->features)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2()
+safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceFeatures2::safe_VkPhysicalDeviceFeatures2(const safe_VkPhysicalDeviceFeatures2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     features = src.features;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceFeatures2& safe_VkPhysicalDeviceFeatures2::operator=(const safe_VkPhysicalDeviceFeatures2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     features = src.features;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceFeatures2::~safe_VkPhysicalDeviceFeatures2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceFeatures2::initialize(const VkPhysicalDeviceFeatures2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     features = in_struct->features;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceFeatures2::initialize(const safe_VkPhysicalDeviceFeatures2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     features = src->features;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const VkPhysicalDeviceProperties2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     properties(in_struct->properties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2()
+safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceProperties2::safe_VkPhysicalDeviceProperties2(const safe_VkPhysicalDeviceProperties2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     properties = src.properties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceProperties2& safe_VkPhysicalDeviceProperties2::operator=(const safe_VkPhysicalDeviceProperties2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     properties = src.properties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceProperties2::~safe_VkPhysicalDeviceProperties2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceProperties2::initialize(const VkPhysicalDeviceProperties2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     properties = in_struct->properties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceProperties2::initialize(const safe_VkPhysicalDeviceProperties2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     properties = src->properties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkFormatProperties2::safe_VkFormatProperties2(const VkFormatProperties2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     formatProperties(in_struct->formatProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkFormatProperties2::safe_VkFormatProperties2()
+safe_VkFormatProperties2::safe_VkFormatProperties2() :
+    pNext(nullptr)
 {}
 
 safe_VkFormatProperties2::safe_VkFormatProperties2(const safe_VkFormatProperties2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     formatProperties = src.formatProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkFormatProperties2& safe_VkFormatProperties2::operator=(const safe_VkFormatProperties2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     formatProperties = src.formatProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkFormatProperties2::~safe_VkFormatProperties2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFormatProperties2::initialize(const VkFormatProperties2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     formatProperties = in_struct->formatProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkFormatProperties2::initialize(const safe_VkFormatProperties2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     formatProperties = src->formatProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const VkImageFormatProperties2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     imageFormatProperties(in_struct->imageFormatProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageFormatProperties2::safe_VkImageFormatProperties2()
+safe_VkImageFormatProperties2::safe_VkImageFormatProperties2() :
+    pNext(nullptr)
 {}
 
 safe_VkImageFormatProperties2::safe_VkImageFormatProperties2(const safe_VkImageFormatProperties2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     imageFormatProperties = src.imageFormatProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageFormatProperties2& safe_VkImageFormatProperties2::operator=(const safe_VkImageFormatProperties2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     imageFormatProperties = src.imageFormatProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageFormatProperties2::~safe_VkImageFormatProperties2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageFormatProperties2::initialize(const VkImageFormatProperties2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     imageFormatProperties = in_struct->imageFormatProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageFormatProperties2::initialize(const safe_VkImageFormatProperties2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     imageFormatProperties = src->imageFormatProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2(const VkPhysicalDeviceImageFormatInfo2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     format(in_struct->format),
     type(in_struct->type),
     tiling(in_struct->tiling),
     usage(in_struct->usage),
     flags(in_struct->flags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2()
+safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceImageFormatInfo2::safe_VkPhysicalDeviceImageFormatInfo2(const safe_VkPhysicalDeviceImageFormatInfo2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     type = src.type;
     tiling = src.tiling;
     usage = src.usage;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceImageFormatInfo2& safe_VkPhysicalDeviceImageFormatInfo2::operator=(const safe_VkPhysicalDeviceImageFormatInfo2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     type = src.type;
     tiling = src.tiling;
     usage = src.usage;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceImageFormatInfo2::~safe_VkPhysicalDeviceImageFormatInfo2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const VkPhysicalDeviceImageFormatInfo2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     format = in_struct->format;
     type = in_struct->type;
     tiling = in_struct->tiling;
     usage = in_struct->usage;
     flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceImageFormatInfo2::initialize(const safe_VkPhysicalDeviceImageFormatInfo2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     format = src->format;
     type = src->type;
     tiling = src->tiling;
     usage = src->usage;
     flags = src->flags;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const VkQueueFamilyProperties2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     queueFamilyProperties(in_struct->queueFamilyProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2()
+safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2() :
+    pNext(nullptr)
 {}
 
 safe_VkQueueFamilyProperties2::safe_VkQueueFamilyProperties2(const safe_VkQueueFamilyProperties2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     queueFamilyProperties = src.queueFamilyProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkQueueFamilyProperties2& safe_VkQueueFamilyProperties2::operator=(const safe_VkQueueFamilyProperties2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     queueFamilyProperties = src.queueFamilyProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkQueueFamilyProperties2::~safe_VkQueueFamilyProperties2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkQueueFamilyProperties2::initialize(const VkQueueFamilyProperties2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     queueFamilyProperties = in_struct->queueFamilyProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkQueueFamilyProperties2::initialize(const safe_VkQueueFamilyProperties2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     queueFamilyProperties = src->queueFamilyProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2(const VkPhysicalDeviceMemoryProperties2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memoryProperties(in_struct->memoryProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2()
+safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMemoryProperties2::safe_VkPhysicalDeviceMemoryProperties2(const safe_VkPhysicalDeviceMemoryProperties2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memoryProperties = src.memoryProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceMemoryProperties2& safe_VkPhysicalDeviceMemoryProperties2::operator=(const safe_VkPhysicalDeviceMemoryProperties2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memoryProperties = src.memoryProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceMemoryProperties2::~safe_VkPhysicalDeviceMemoryProperties2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMemoryProperties2::initialize(const VkPhysicalDeviceMemoryProperties2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memoryProperties = in_struct->memoryProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceMemoryProperties2::initialize(const safe_VkPhysicalDeviceMemoryProperties2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memoryProperties = src->memoryProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const VkSparseImageFormatProperties2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     properties(in_struct->properties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2()
+safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2() :
+    pNext(nullptr)
 {}
 
 safe_VkSparseImageFormatProperties2::safe_VkSparseImageFormatProperties2(const safe_VkSparseImageFormatProperties2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     properties = src.properties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSparseImageFormatProperties2& safe_VkSparseImageFormatProperties2::operator=(const safe_VkSparseImageFormatProperties2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     properties = src.properties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSparseImageFormatProperties2::~safe_VkSparseImageFormatProperties2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSparseImageFormatProperties2::initialize(const VkSparseImageFormatProperties2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     properties = in_struct->properties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSparseImageFormatProperties2::initialize(const safe_VkSparseImageFormatProperties2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     properties = src->properties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     format(in_struct->format),
     type(in_struct->type),
     samples(in_struct->samples),
     usage(in_struct->usage),
     tiling(in_struct->tiling)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2()
+safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceSparseImageFormatInfo2::safe_VkPhysicalDeviceSparseImageFormatInfo2(const safe_VkPhysicalDeviceSparseImageFormatInfo2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     type = src.type;
     samples = src.samples;
     usage = src.usage;
     tiling = src.tiling;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceSparseImageFormatInfo2& safe_VkPhysicalDeviceSparseImageFormatInfo2::operator=(const safe_VkPhysicalDeviceSparseImageFormatInfo2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     type = src.type;
     samples = src.samples;
     usage = src.usage;
     tiling = src.tiling;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceSparseImageFormatInfo2::~safe_VkPhysicalDeviceSparseImageFormatInfo2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const VkPhysicalDeviceSparseImageFormatInfo2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     format = in_struct->format;
     type = in_struct->type;
     samples = in_struct->samples;
     usage = in_struct->usage;
     tiling = in_struct->tiling;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceSparseImageFormatInfo2::initialize(const safe_VkPhysicalDeviceSparseImageFormatInfo2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     format = src->format;
     type = src->type;
     samples = src->samples;
     usage = src->usage;
     tiling = src->tiling;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties(const VkPhysicalDevicePointClippingProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pointClippingBehavior(in_struct->pointClippingBehavior)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties()
+safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDevicePointClippingProperties::safe_VkPhysicalDevicePointClippingProperties(const safe_VkPhysicalDevicePointClippingProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pointClippingBehavior = src.pointClippingBehavior;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDevicePointClippingProperties& safe_VkPhysicalDevicePointClippingProperties::operator=(const safe_VkPhysicalDevicePointClippingProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pointClippingBehavior = src.pointClippingBehavior;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDevicePointClippingProperties::~safe_VkPhysicalDevicePointClippingProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDevicePointClippingProperties::initialize(const VkPhysicalDevicePointClippingProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pointClippingBehavior = in_struct->pointClippingBehavior;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDevicePointClippingProperties::initialize(const safe_VkPhysicalDevicePointClippingProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pointClippingBehavior = src->pointClippingBehavior;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     aspectReferenceCount(in_struct->aspectReferenceCount),
     pAspectReferences(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAspectReferences) {
         pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount];
         memcpy ((void *)pAspectReferences, (void *)in_struct->pAspectReferences, sizeof(VkInputAttachmentAspectReference)*in_struct->aspectReferenceCount);
@@ -7399,15 +7853,16 @@ safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachme
 }
 
 safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo() :
+    pNext(nullptr),
     pAspectReferences(nullptr)
 {}
 
 safe_VkRenderPassInputAttachmentAspectCreateInfo::safe_VkRenderPassInputAttachmentAspectCreateInfo(const safe_VkRenderPassInputAttachmentAspectCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     aspectReferenceCount = src.aspectReferenceCount;
     pAspectReferences = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAspectReferences) {
         pAspectReferences = new VkInputAttachmentAspectReference[src.aspectReferenceCount];
         memcpy ((void *)pAspectReferences, (void *)src.pAspectReferences, sizeof(VkInputAttachmentAspectReference)*src.aspectReferenceCount);
@@ -7420,11 +7875,13 @@ safe_VkRenderPassInputAttachmentAspectCreateInfo& safe_VkRenderPassInputAttachme
 
     if (pAspectReferences)
         delete[] pAspectReferences;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     aspectReferenceCount = src.aspectReferenceCount;
     pAspectReferences = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAspectReferences) {
         pAspectReferences = new VkInputAttachmentAspectReference[src.aspectReferenceCount];
         memcpy ((void *)pAspectReferences, (void *)src.pAspectReferences, sizeof(VkInputAttachmentAspectReference)*src.aspectReferenceCount);
@@ -7437,14 +7894,16 @@ safe_VkRenderPassInputAttachmentAspectCreateInfo::~safe_VkRenderPassInputAttachm
 {
     if (pAspectReferences)
         delete[] pAspectReferences;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const VkRenderPassInputAttachmentAspectCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     aspectReferenceCount = in_struct->aspectReferenceCount;
     pAspectReferences = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAspectReferences) {
         pAspectReferences = new VkInputAttachmentAspectReference[in_struct->aspectReferenceCount];
         memcpy ((void *)pAspectReferences, (void *)in_struct->pAspectReferences, sizeof(VkInputAttachmentAspectReference)*in_struct->aspectReferenceCount);
@@ -7454,9 +7913,9 @@ void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const VkRender
 void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const safe_VkRenderPassInputAttachmentAspectCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     aspectReferenceCount = src->aspectReferenceCount;
     pAspectReferences = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAspectReferences) {
         pAspectReferences = new VkInputAttachmentAspectReference[src->aspectReferenceCount];
         memcpy ((void *)pAspectReferences, (void *)src->pAspectReferences, sizeof(VkInputAttachmentAspectReference)*src->aspectReferenceCount);
@@ -7465,101 +7924,110 @@ void safe_VkRenderPassInputAttachmentAspectCreateInfo::initialize(const safe_VkR
 
 safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     usage(in_struct->usage)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo()
+safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkImageViewUsageCreateInfo::safe_VkImageViewUsageCreateInfo(const safe_VkImageViewUsageCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     usage = src.usage;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageViewUsageCreateInfo& safe_VkImageViewUsageCreateInfo::operator=(const safe_VkImageViewUsageCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     usage = src.usage;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageViewUsageCreateInfo::~safe_VkImageViewUsageCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageViewUsageCreateInfo::initialize(const VkImageViewUsageCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     usage = in_struct->usage;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageViewUsageCreateInfo::initialize(const safe_VkImageViewUsageCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     usage = src->usage;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     domainOrigin(in_struct->domainOrigin)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo()
+safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineTessellationDomainOriginStateCreateInfo::safe_VkPipelineTessellationDomainOriginStateCreateInfo(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     domainOrigin = src.domainOrigin;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineTessellationDomainOriginStateCreateInfo& safe_VkPipelineTessellationDomainOriginStateCreateInfo::operator=(const safe_VkPipelineTessellationDomainOriginStateCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     domainOrigin = src.domainOrigin;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineTessellationDomainOriginStateCreateInfo::~safe_VkPipelineTessellationDomainOriginStateCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize(const VkPipelineTessellationDomainOriginStateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     domainOrigin = in_struct->domainOrigin;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineTessellationDomainOriginStateCreateInfo::initialize(const safe_VkPipelineTessellationDomainOriginStateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     domainOrigin = src->domainOrigin;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const VkRenderPassMultiviewCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     subpassCount(in_struct->subpassCount),
     pViewMasks(nullptr),
     dependencyCount(in_struct->dependencyCount),
@@ -7567,6 +8035,7 @@ safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const
     correlationMaskCount(in_struct->correlationMaskCount),
     pCorrelationMasks(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewMasks) {
         pViewMasks = new uint32_t[in_struct->subpassCount];
         memcpy ((void *)pViewMasks, (void *)in_struct->pViewMasks, sizeof(uint32_t)*in_struct->subpassCount);
@@ -7582,6 +8051,7 @@ safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const
 }
 
 safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo() :
+    pNext(nullptr),
     pViewMasks(nullptr),
     pViewOffsets(nullptr),
     pCorrelationMasks(nullptr)
@@ -7590,13 +8060,13 @@ safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo() :
 safe_VkRenderPassMultiviewCreateInfo::safe_VkRenderPassMultiviewCreateInfo(const safe_VkRenderPassMultiviewCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     subpassCount = src.subpassCount;
     pViewMasks = nullptr;
     dependencyCount = src.dependencyCount;
     pViewOffsets = nullptr;
     correlationMaskCount = src.correlationMaskCount;
     pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewMasks) {
         pViewMasks = new uint32_t[src.subpassCount];
         memcpy ((void *)pViewMasks, (void *)src.pViewMasks, sizeof(uint32_t)*src.subpassCount);
@@ -7621,15 +8091,17 @@ safe_VkRenderPassMultiviewCreateInfo& safe_VkRenderPassMultiviewCreateInfo::oper
         delete[] pViewOffsets;
     if (pCorrelationMasks)
         delete[] pCorrelationMasks;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     subpassCount = src.subpassCount;
     pViewMasks = nullptr;
     dependencyCount = src.dependencyCount;
     pViewOffsets = nullptr;
     correlationMaskCount = src.correlationMaskCount;
     pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewMasks) {
         pViewMasks = new uint32_t[src.subpassCount];
         memcpy ((void *)pViewMasks, (void *)src.pViewMasks, sizeof(uint32_t)*src.subpassCount);
@@ -7654,18 +8126,20 @@ safe_VkRenderPassMultiviewCreateInfo::~safe_VkRenderPassMultiviewCreateInfo()
         delete[] pViewOffsets;
     if (pCorrelationMasks)
         delete[] pCorrelationMasks;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassMultiviewCreateInfo::initialize(const VkRenderPassMultiviewCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     subpassCount = in_struct->subpassCount;
     pViewMasks = nullptr;
     dependencyCount = in_struct->dependencyCount;
     pViewOffsets = nullptr;
     correlationMaskCount = in_struct->correlationMaskCount;
     pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewMasks) {
         pViewMasks = new uint32_t[in_struct->subpassCount];
         memcpy ((void *)pViewMasks, (void *)in_struct->pViewMasks, sizeof(uint32_t)*in_struct->subpassCount);
@@ -7683,13 +8157,13 @@ void safe_VkRenderPassMultiviewCreateInfo::initialize(const VkRenderPassMultivie
 void safe_VkRenderPassMultiviewCreateInfo::initialize(const safe_VkRenderPassMultiviewCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     subpassCount = src->subpassCount;
     pViewMasks = nullptr;
     dependencyCount = src->dependencyCount;
     pViewOffsets = nullptr;
     correlationMaskCount = src->correlationMaskCount;
     pCorrelationMasks = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pViewMasks) {
         pViewMasks = new uint32_t[src->subpassCount];
         memcpy ((void *)pViewMasks, (void *)src->pViewMasks, sizeof(uint32_t)*src->subpassCount);
@@ -7706,366 +8180,400 @@ void safe_VkRenderPassMultiviewCreateInfo::initialize(const safe_VkRenderPassMul
 
 safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures(const VkPhysicalDeviceMultiviewFeatures* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     multiview(in_struct->multiview),
     multiviewGeometryShader(in_struct->multiviewGeometryShader),
     multiviewTessellationShader(in_struct->multiviewTessellationShader)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures()
+safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMultiviewFeatures::safe_VkPhysicalDeviceMultiviewFeatures(const safe_VkPhysicalDeviceMultiviewFeatures& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     multiview = src.multiview;
     multiviewGeometryShader = src.multiviewGeometryShader;
     multiviewTessellationShader = src.multiviewTessellationShader;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceMultiviewFeatures& safe_VkPhysicalDeviceMultiviewFeatures::operator=(const safe_VkPhysicalDeviceMultiviewFeatures& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     multiview = src.multiview;
     multiviewGeometryShader = src.multiviewGeometryShader;
     multiviewTessellationShader = src.multiviewTessellationShader;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceMultiviewFeatures::~safe_VkPhysicalDeviceMultiviewFeatures()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const VkPhysicalDeviceMultiviewFeatures* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     multiview = in_struct->multiview;
     multiviewGeometryShader = in_struct->multiviewGeometryShader;
     multiviewTessellationShader = in_struct->multiviewTessellationShader;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceMultiviewFeatures::initialize(const safe_VkPhysicalDeviceMultiviewFeatures* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     multiview = src->multiview;
     multiviewGeometryShader = src->multiviewGeometryShader;
     multiviewTessellationShader = src->multiviewTessellationShader;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties(const VkPhysicalDeviceMultiviewProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxMultiviewViewCount(in_struct->maxMultiviewViewCount),
     maxMultiviewInstanceIndex(in_struct->maxMultiviewInstanceIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties()
+safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMultiviewProperties::safe_VkPhysicalDeviceMultiviewProperties(const safe_VkPhysicalDeviceMultiviewProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxMultiviewViewCount = src.maxMultiviewViewCount;
     maxMultiviewInstanceIndex = src.maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceMultiviewProperties& safe_VkPhysicalDeviceMultiviewProperties::operator=(const safe_VkPhysicalDeviceMultiviewProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxMultiviewViewCount = src.maxMultiviewViewCount;
     maxMultiviewInstanceIndex = src.maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceMultiviewProperties::~safe_VkPhysicalDeviceMultiviewProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMultiviewProperties::initialize(const VkPhysicalDeviceMultiviewProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxMultiviewViewCount = in_struct->maxMultiviewViewCount;
     maxMultiviewInstanceIndex = in_struct->maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceMultiviewProperties::initialize(const safe_VkPhysicalDeviceMultiviewProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxMultiviewViewCount = src->maxMultiviewViewCount;
     maxMultiviewInstanceIndex = src->maxMultiviewInstanceIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures(const VkPhysicalDeviceVariablePointersFeatures* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     variablePointersStorageBuffer(in_struct->variablePointersStorageBuffer),
     variablePointers(in_struct->variablePointers)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures()
+safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceVariablePointersFeatures::safe_VkPhysicalDeviceVariablePointersFeatures(const safe_VkPhysicalDeviceVariablePointersFeatures& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     variablePointersStorageBuffer = src.variablePointersStorageBuffer;
     variablePointers = src.variablePointers;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceVariablePointersFeatures& safe_VkPhysicalDeviceVariablePointersFeatures::operator=(const safe_VkPhysicalDeviceVariablePointersFeatures& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     variablePointersStorageBuffer = src.variablePointersStorageBuffer;
     variablePointers = src.variablePointers;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceVariablePointersFeatures::~safe_VkPhysicalDeviceVariablePointersFeatures()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const VkPhysicalDeviceVariablePointersFeatures* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     variablePointersStorageBuffer = in_struct->variablePointersStorageBuffer;
     variablePointers = in_struct->variablePointers;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceVariablePointersFeatures::initialize(const safe_VkPhysicalDeviceVariablePointersFeatures* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     variablePointersStorageBuffer = src->variablePointersStorageBuffer;
     variablePointers = src->variablePointers;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     protectedMemory(in_struct->protectedMemory)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures()
+safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceProtectedMemoryFeatures::safe_VkPhysicalDeviceProtectedMemoryFeatures(const safe_VkPhysicalDeviceProtectedMemoryFeatures& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     protectedMemory = src.protectedMemory;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceProtectedMemoryFeatures& safe_VkPhysicalDeviceProtectedMemoryFeatures::operator=(const safe_VkPhysicalDeviceProtectedMemoryFeatures& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     protectedMemory = src.protectedMemory;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceProtectedMemoryFeatures::~safe_VkPhysicalDeviceProtectedMemoryFeatures()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const VkPhysicalDeviceProtectedMemoryFeatures* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     protectedMemory = in_struct->protectedMemory;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceProtectedMemoryFeatures::initialize(const safe_VkPhysicalDeviceProtectedMemoryFeatures* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     protectedMemory = src->protectedMemory;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties(const VkPhysicalDeviceProtectedMemoryProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     protectedNoFault(in_struct->protectedNoFault)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties()
+safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceProtectedMemoryProperties::safe_VkPhysicalDeviceProtectedMemoryProperties(const safe_VkPhysicalDeviceProtectedMemoryProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     protectedNoFault = src.protectedNoFault;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceProtectedMemoryProperties& safe_VkPhysicalDeviceProtectedMemoryProperties::operator=(const safe_VkPhysicalDeviceProtectedMemoryProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     protectedNoFault = src.protectedNoFault;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceProtectedMemoryProperties::~safe_VkPhysicalDeviceProtectedMemoryProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const VkPhysicalDeviceProtectedMemoryProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     protectedNoFault = in_struct->protectedNoFault;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceProtectedMemoryProperties::initialize(const safe_VkPhysicalDeviceProtectedMemoryProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     protectedNoFault = src->protectedNoFault;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const VkDeviceQueueInfo2* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     queueFamilyIndex(in_struct->queueFamilyIndex),
     queueIndex(in_struct->queueIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2()
+safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceQueueInfo2::safe_VkDeviceQueueInfo2(const safe_VkDeviceQueueInfo2& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueFamilyIndex = src.queueFamilyIndex;
     queueIndex = src.queueIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceQueueInfo2& safe_VkDeviceQueueInfo2::operator=(const safe_VkDeviceQueueInfo2& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     queueFamilyIndex = src.queueFamilyIndex;
     queueIndex = src.queueIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceQueueInfo2::~safe_VkDeviceQueueInfo2()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceQueueInfo2::initialize(const VkDeviceQueueInfo2* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     queueFamilyIndex = in_struct->queueFamilyIndex;
     queueIndex = in_struct->queueIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceQueueInfo2::initialize(const safe_VkDeviceQueueInfo2* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     queueFamilyIndex = src->queueFamilyIndex;
     queueIndex = src->queueIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const VkProtectedSubmitInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     protectedSubmit(in_struct->protectedSubmit)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo()
+safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkProtectedSubmitInfo::safe_VkProtectedSubmitInfo(const safe_VkProtectedSubmitInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     protectedSubmit = src.protectedSubmit;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkProtectedSubmitInfo& safe_VkProtectedSubmitInfo::operator=(const safe_VkProtectedSubmitInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     protectedSubmit = src.protectedSubmit;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkProtectedSubmitInfo::~safe_VkProtectedSubmitInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkProtectedSubmitInfo::initialize(const VkProtectedSubmitInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     protectedSubmit = in_struct->protectedSubmit;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkProtectedSubmitInfo::initialize(const safe_VkProtectedSubmitInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     protectedSubmit = src->protectedSubmit;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     format(in_struct->format),
     ycbcrModel(in_struct->ycbcrModel),
     ycbcrRange(in_struct->ycbcrRange),
@@ -8075,15 +8583,16 @@ safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo
     chromaFilter(in_struct->chromaFilter),
     forceExplicitReconstruction(in_struct->forceExplicitReconstruction)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo()
+safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo(const safe_VkSamplerYcbcrConversionCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     ycbcrModel = src.ycbcrModel;
     ycbcrRange = src.ycbcrRange;
@@ -8092,15 +8601,17 @@ safe_VkSamplerYcbcrConversionCreateInfo::safe_VkSamplerYcbcrConversionCreateInfo
     yChromaOffset = src.yChromaOffset;
     chromaFilter = src.chromaFilter;
     forceExplicitReconstruction = src.forceExplicitReconstruction;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSamplerYcbcrConversionCreateInfo& safe_VkSamplerYcbcrConversionCreateInfo::operator=(const safe_VkSamplerYcbcrConversionCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     ycbcrModel = src.ycbcrModel;
     ycbcrRange = src.ycbcrRange;
@@ -8109,18 +8620,20 @@ safe_VkSamplerYcbcrConversionCreateInfo& safe_VkSamplerYcbcrConversionCreateInfo
     yChromaOffset = src.yChromaOffset;
     chromaFilter = src.chromaFilter;
     forceExplicitReconstruction = src.forceExplicitReconstruction;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSamplerYcbcrConversionCreateInfo::~safe_VkSamplerYcbcrConversionCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const VkSamplerYcbcrConversionCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     format = in_struct->format;
     ycbcrModel = in_struct->ycbcrModel;
     ycbcrRange = in_struct->ycbcrRange;
@@ -8129,12 +8642,12 @@ void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const VkSamplerYcbcrCon
     yChromaOffset = in_struct->yChromaOffset;
     chromaFilter = in_struct->chromaFilter;
     forceExplicitReconstruction = in_struct->forceExplicitReconstruction;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const safe_VkSamplerYcbcrConversionCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     format = src->format;
     ycbcrModel = src->ycbcrModel;
     ycbcrRange = src->ycbcrRange;
@@ -8143,246 +8656,271 @@ void safe_VkSamplerYcbcrConversionCreateInfo::initialize(const safe_VkSamplerYcb
     yChromaOffset = src->yChromaOffset;
     chromaFilter = src->chromaFilter;
     forceExplicitReconstruction = src->forceExplicitReconstruction;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     conversion(in_struct->conversion)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo()
+safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkSamplerYcbcrConversionInfo::safe_VkSamplerYcbcrConversionInfo(const safe_VkSamplerYcbcrConversionInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     conversion = src.conversion;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSamplerYcbcrConversionInfo& safe_VkSamplerYcbcrConversionInfo::operator=(const safe_VkSamplerYcbcrConversionInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     conversion = src.conversion;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSamplerYcbcrConversionInfo::~safe_VkSamplerYcbcrConversionInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSamplerYcbcrConversionInfo::initialize(const VkSamplerYcbcrConversionInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     conversion = in_struct->conversion;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSamplerYcbcrConversionInfo::initialize(const safe_VkSamplerYcbcrConversionInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     conversion = src->conversion;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const VkBindImagePlaneMemoryInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     planeAspect(in_struct->planeAspect)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo()
+safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkBindImagePlaneMemoryInfo::safe_VkBindImagePlaneMemoryInfo(const safe_VkBindImagePlaneMemoryInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     planeAspect = src.planeAspect;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBindImagePlaneMemoryInfo& safe_VkBindImagePlaneMemoryInfo::operator=(const safe_VkBindImagePlaneMemoryInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     planeAspect = src.planeAspect;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBindImagePlaneMemoryInfo::~safe_VkBindImagePlaneMemoryInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindImagePlaneMemoryInfo::initialize(const VkBindImagePlaneMemoryInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     planeAspect = in_struct->planeAspect;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBindImagePlaneMemoryInfo::initialize(const safe_VkBindImagePlaneMemoryInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     planeAspect = src->planeAspect;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo(const VkImagePlaneMemoryRequirementsInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     planeAspect(in_struct->planeAspect)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo()
+safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkImagePlaneMemoryRequirementsInfo::safe_VkImagePlaneMemoryRequirementsInfo(const safe_VkImagePlaneMemoryRequirementsInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     planeAspect = src.planeAspect;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImagePlaneMemoryRequirementsInfo& safe_VkImagePlaneMemoryRequirementsInfo::operator=(const safe_VkImagePlaneMemoryRequirementsInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     planeAspect = src.planeAspect;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImagePlaneMemoryRequirementsInfo::~safe_VkImagePlaneMemoryRequirementsInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const VkImagePlaneMemoryRequirementsInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     planeAspect = in_struct->planeAspect;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImagePlaneMemoryRequirementsInfo::initialize(const safe_VkImagePlaneMemoryRequirementsInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     planeAspect = src->planeAspect;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     samplerYcbcrConversion(in_struct->samplerYcbcrConversion)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures()
+safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     samplerYcbcrConversion = src.samplerYcbcrConversion;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::operator=(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     samplerYcbcrConversion = src.samplerYcbcrConversion;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::~safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize(const VkPhysicalDeviceSamplerYcbcrConversionFeatures* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     samplerYcbcrConversion = in_struct->samplerYcbcrConversion;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures::initialize(const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     samplerYcbcrConversion = src->samplerYcbcrConversion;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties(const VkSamplerYcbcrConversionImageFormatProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     combinedImageSamplerDescriptorCount(in_struct->combinedImageSamplerDescriptorCount)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties()
+safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkSamplerYcbcrConversionImageFormatProperties::safe_VkSamplerYcbcrConversionImageFormatProperties(const safe_VkSamplerYcbcrConversionImageFormatProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     combinedImageSamplerDescriptorCount = src.combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSamplerYcbcrConversionImageFormatProperties& safe_VkSamplerYcbcrConversionImageFormatProperties::operator=(const safe_VkSamplerYcbcrConversionImageFormatProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     combinedImageSamplerDescriptorCount = src.combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSamplerYcbcrConversionImageFormatProperties::~safe_VkSamplerYcbcrConversionImageFormatProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize(const VkSamplerYcbcrConversionImageFormatProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     combinedImageSamplerDescriptorCount = in_struct->combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSamplerYcbcrConversionImageFormatProperties::initialize(const safe_VkSamplerYcbcrConversionImageFormatProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     combinedImageSamplerDescriptorCount = src->combinedImageSamplerDescriptorCount;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     descriptorUpdateEntryCount(in_struct->descriptorUpdateEntryCount),
     pDescriptorUpdateEntries(nullptr),
@@ -8392,6 +8930,7 @@ safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreate
     pipelineLayout(in_struct->pipelineLayout),
     set(in_struct->set)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDescriptorUpdateEntries) {
         pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount];
         memcpy ((void *)pDescriptorUpdateEntries, (void *)in_struct->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*in_struct->descriptorUpdateEntryCount);
@@ -8399,13 +8938,13 @@ safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreate
 }
 
 safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo() :
+    pNext(nullptr),
     pDescriptorUpdateEntries(nullptr)
 {}
 
 safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreateInfo(const safe_VkDescriptorUpdateTemplateCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     descriptorUpdateEntryCount = src.descriptorUpdateEntryCount;
     pDescriptorUpdateEntries = nullptr;
@@ -8414,6 +8953,7 @@ safe_VkDescriptorUpdateTemplateCreateInfo::safe_VkDescriptorUpdateTemplateCreate
     pipelineBindPoint = src.pipelineBindPoint;
     pipelineLayout = src.pipelineLayout;
     set = src.set;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDescriptorUpdateEntries) {
         pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[src.descriptorUpdateEntryCount];
         memcpy ((void *)pDescriptorUpdateEntries, (void *)src.pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*src.descriptorUpdateEntryCount);
@@ -8426,9 +8966,10 @@ safe_VkDescriptorUpdateTemplateCreateInfo& safe_VkDescriptorUpdateTemplateCreate
 
     if (pDescriptorUpdateEntries)
         delete[] pDescriptorUpdateEntries;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     descriptorUpdateEntryCount = src.descriptorUpdateEntryCount;
     pDescriptorUpdateEntries = nullptr;
@@ -8437,6 +8978,7 @@ safe_VkDescriptorUpdateTemplateCreateInfo& safe_VkDescriptorUpdateTemplateCreate
     pipelineBindPoint = src.pipelineBindPoint;
     pipelineLayout = src.pipelineLayout;
     set = src.set;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDescriptorUpdateEntries) {
         pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[src.descriptorUpdateEntryCount];
         memcpy ((void *)pDescriptorUpdateEntries, (void *)src.pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*src.descriptorUpdateEntryCount);
@@ -8449,12 +8991,13 @@ safe_VkDescriptorUpdateTemplateCreateInfo::~safe_VkDescriptorUpdateTemplateCreat
 {
     if (pDescriptorUpdateEntries)
         delete[] pDescriptorUpdateEntries;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const VkDescriptorUpdateTemplateCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     descriptorUpdateEntryCount = in_struct->descriptorUpdateEntryCount;
     pDescriptorUpdateEntries = nullptr;
@@ -8463,6 +9006,7 @@ void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const VkDescriptorUpd
     pipelineBindPoint = in_struct->pipelineBindPoint;
     pipelineLayout = in_struct->pipelineLayout;
     set = in_struct->set;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDescriptorUpdateEntries) {
         pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[in_struct->descriptorUpdateEntryCount];
         memcpy ((void *)pDescriptorUpdateEntries, (void *)in_struct->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*in_struct->descriptorUpdateEntryCount);
@@ -8472,7 +9016,6 @@ void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const VkDescriptorUpd
 void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const safe_VkDescriptorUpdateTemplateCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     descriptorUpdateEntryCount = src->descriptorUpdateEntryCount;
     pDescriptorUpdateEntries = nullptr;
@@ -8481,6 +9024,7 @@ void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const safe_VkDescript
     pipelineBindPoint = src->pipelineBindPoint;
     pipelineLayout = src->pipelineLayout;
     set = src->set;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDescriptorUpdateEntries) {
         pDescriptorUpdateEntries = new VkDescriptorUpdateTemplateEntry[src->descriptorUpdateEntryCount];
         memcpy ((void *)pDescriptorUpdateEntries, (void *)src->pDescriptorUpdateEntries, sizeof(VkDescriptorUpdateTemplateEntry)*src->descriptorUpdateEntryCount);
@@ -8489,235 +9033,256 @@ void safe_VkDescriptorUpdateTemplateCreateInfo::initialize(const safe_VkDescript
 
 safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo(const VkPhysicalDeviceExternalImageFormatInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo()
+safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceExternalImageFormatInfo::safe_VkPhysicalDeviceExternalImageFormatInfo(const safe_VkPhysicalDeviceExternalImageFormatInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceExternalImageFormatInfo& safe_VkPhysicalDeviceExternalImageFormatInfo::operator=(const safe_VkPhysicalDeviceExternalImageFormatInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceExternalImageFormatInfo::~safe_VkPhysicalDeviceExternalImageFormatInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const VkPhysicalDeviceExternalImageFormatInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceExternalImageFormatInfo::initialize(const safe_VkPhysicalDeviceExternalImageFormatInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const VkExternalImageFormatProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     externalMemoryProperties(in_struct->externalMemoryProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties()
+safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalImageFormatProperties::safe_VkExternalImageFormatProperties(const safe_VkExternalImageFormatProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     externalMemoryProperties = src.externalMemoryProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalImageFormatProperties& safe_VkExternalImageFormatProperties::operator=(const safe_VkExternalImageFormatProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     externalMemoryProperties = src.externalMemoryProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalImageFormatProperties::~safe_VkExternalImageFormatProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalImageFormatProperties::initialize(const VkExternalImageFormatProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     externalMemoryProperties = in_struct->externalMemoryProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalImageFormatProperties::initialize(const safe_VkExternalImageFormatProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     externalMemoryProperties = src->externalMemoryProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo(const VkPhysicalDeviceExternalBufferInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     usage(in_struct->usage),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo()
+safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceExternalBufferInfo::safe_VkPhysicalDeviceExternalBufferInfo(const safe_VkPhysicalDeviceExternalBufferInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     usage = src.usage;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceExternalBufferInfo& safe_VkPhysicalDeviceExternalBufferInfo::operator=(const safe_VkPhysicalDeviceExternalBufferInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     usage = src.usage;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceExternalBufferInfo::~safe_VkPhysicalDeviceExternalBufferInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const VkPhysicalDeviceExternalBufferInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     usage = in_struct->usage;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceExternalBufferInfo::initialize(const safe_VkPhysicalDeviceExternalBufferInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     usage = src->usage;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const VkExternalBufferProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     externalMemoryProperties(in_struct->externalMemoryProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalBufferProperties::safe_VkExternalBufferProperties()
+safe_VkExternalBufferProperties::safe_VkExternalBufferProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalBufferProperties::safe_VkExternalBufferProperties(const safe_VkExternalBufferProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     externalMemoryProperties = src.externalMemoryProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalBufferProperties& safe_VkExternalBufferProperties::operator=(const safe_VkExternalBufferProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     externalMemoryProperties = src.externalMemoryProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalBufferProperties::~safe_VkExternalBufferProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalBufferProperties::initialize(const VkExternalBufferProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     externalMemoryProperties = in_struct->externalMemoryProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalBufferProperties::initialize(const safe_VkExternalBufferProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     externalMemoryProperties = src->externalMemoryProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const VkPhysicalDeviceIDProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     deviceNodeMask(in_struct->deviceNodeMask),
     deviceLUIDValid(in_struct->deviceLUIDValid)
 {
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         deviceUUID[i] = in_struct->deviceUUID[i];
     }
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         driverUUID[i] = in_struct->driverUUID[i];
     }
-    for (uint32_t i=0; i<VK_LUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
         deviceLUID[i] = in_struct->deviceLUID[i];
     }
 }
 
-safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties()
+safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceIDProperties::safe_VkPhysicalDeviceIDProperties(const safe_VkPhysicalDeviceIDProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     deviceNodeMask = src.deviceNodeMask;
     deviceLUIDValid = src.deviceLUIDValid;
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         deviceUUID[i] = src.deviceUUID[i];
     }
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         driverUUID[i] = src.driverUUID[i];
     }
-    for (uint32_t i=0; i<VK_LUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
         deviceLUID[i] = src.deviceLUID[i];
     }
 }
@@ -8726,18 +9291,20 @@ safe_VkPhysicalDeviceIDProperties& safe_VkPhysicalDeviceIDProperties::operator=(
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     deviceNodeMask = src.deviceNodeMask;
     deviceLUIDValid = src.deviceLUIDValid;
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         deviceUUID[i] = src.deviceUUID[i];
     }
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         driverUUID[i] = src.driverUUID[i];
     }
-    for (uint32_t i=0; i<VK_LUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
         deviceLUID[i] = src.deviceLUID[i];
     }
 
@@ -8746,21 +9313,23 @@ safe_VkPhysicalDeviceIDProperties& safe_VkPhysicalDeviceIDProperties::operator=(
 
 safe_VkPhysicalDeviceIDProperties::~safe_VkPhysicalDeviceIDProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceIDProperties::initialize(const VkPhysicalDeviceIDProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     deviceNodeMask = in_struct->deviceNodeMask;
     deviceLUIDValid = in_struct->deviceLUIDValid;
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         deviceUUID[i] = in_struct->deviceUUID[i];
     }
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         driverUUID[i] = in_struct->driverUUID[i];
     }
-    for (uint32_t i=0; i<VK_LUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
         deviceLUID[i] = in_struct->deviceLUID[i];
     }
 }
@@ -8768,612 +9337,671 @@ void safe_VkPhysicalDeviceIDProperties::initialize(const VkPhysicalDeviceIDPrope
 void safe_VkPhysicalDeviceIDProperties::initialize(const safe_VkPhysicalDeviceIDProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     deviceNodeMask = src->deviceNodeMask;
     deviceLUIDValid = src->deviceLUIDValid;
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         deviceUUID[i] = src->deviceUUID[i];
     }
-    for (uint32_t i=0; i<VK_UUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_UUID_SIZE; ++i) {
         driverUUID[i] = src->driverUUID[i];
     }
-    for (uint32_t i=0; i<VK_LUID_SIZE; ++i) {
+    for (uint32_t i = 0; i < VK_LUID_SIZE; ++i) {
         deviceLUID[i] = src->deviceLUID[i];
     }
 }
 
 safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const VkExternalMemoryImageCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleTypes(in_struct->handleTypes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo()
+safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalMemoryImageCreateInfo::safe_VkExternalMemoryImageCreateInfo(const safe_VkExternalMemoryImageCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalMemoryImageCreateInfo& safe_VkExternalMemoryImageCreateInfo::operator=(const safe_VkExternalMemoryImageCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalMemoryImageCreateInfo::~safe_VkExternalMemoryImageCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalMemoryImageCreateInfo::initialize(const VkExternalMemoryImageCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalMemoryImageCreateInfo::initialize(const safe_VkExternalMemoryImageCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleTypes = src->handleTypes;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo(const VkExternalMemoryBufferCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleTypes(in_struct->handleTypes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo()
+safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalMemoryBufferCreateInfo::safe_VkExternalMemoryBufferCreateInfo(const safe_VkExternalMemoryBufferCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalMemoryBufferCreateInfo& safe_VkExternalMemoryBufferCreateInfo::operator=(const safe_VkExternalMemoryBufferCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalMemoryBufferCreateInfo::~safe_VkExternalMemoryBufferCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalMemoryBufferCreateInfo::initialize(const VkExternalMemoryBufferCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalMemoryBufferCreateInfo::initialize(const safe_VkExternalMemoryBufferCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleTypes = src->handleTypes;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const VkExportMemoryAllocateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleTypes(in_struct->handleTypes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo()
+safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkExportMemoryAllocateInfo::safe_VkExportMemoryAllocateInfo(const safe_VkExportMemoryAllocateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExportMemoryAllocateInfo& safe_VkExportMemoryAllocateInfo::operator=(const safe_VkExportMemoryAllocateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExportMemoryAllocateInfo::~safe_VkExportMemoryAllocateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportMemoryAllocateInfo::initialize(const VkExportMemoryAllocateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExportMemoryAllocateInfo::initialize(const safe_VkExportMemoryAllocateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleTypes = src->handleTypes;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo(const VkPhysicalDeviceExternalFenceInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo()
+safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceExternalFenceInfo::safe_VkPhysicalDeviceExternalFenceInfo(const safe_VkPhysicalDeviceExternalFenceInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceExternalFenceInfo& safe_VkPhysicalDeviceExternalFenceInfo::operator=(const safe_VkPhysicalDeviceExternalFenceInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceExternalFenceInfo::~safe_VkPhysicalDeviceExternalFenceInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const VkPhysicalDeviceExternalFenceInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceExternalFenceInfo::initialize(const safe_VkPhysicalDeviceExternalFenceInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const VkExternalFenceProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
     compatibleHandleTypes(in_struct->compatibleHandleTypes),
     externalFenceFeatures(in_struct->externalFenceFeatures)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalFenceProperties::safe_VkExternalFenceProperties()
+safe_VkExternalFenceProperties::safe_VkExternalFenceProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalFenceProperties::safe_VkExternalFenceProperties(const safe_VkExternalFenceProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     exportFromImportedHandleTypes = src.exportFromImportedHandleTypes;
     compatibleHandleTypes = src.compatibleHandleTypes;
     externalFenceFeatures = src.externalFenceFeatures;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalFenceProperties& safe_VkExternalFenceProperties::operator=(const safe_VkExternalFenceProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     exportFromImportedHandleTypes = src.exportFromImportedHandleTypes;
     compatibleHandleTypes = src.compatibleHandleTypes;
     externalFenceFeatures = src.externalFenceFeatures;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalFenceProperties::~safe_VkExternalFenceProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalFenceProperties::initialize(const VkExternalFenceProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
     compatibleHandleTypes = in_struct->compatibleHandleTypes;
     externalFenceFeatures = in_struct->externalFenceFeatures;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalFenceProperties::initialize(const safe_VkExternalFenceProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     exportFromImportedHandleTypes = src->exportFromImportedHandleTypes;
     compatibleHandleTypes = src->compatibleHandleTypes;
     externalFenceFeatures = src->externalFenceFeatures;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const VkExportFenceCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleTypes(in_struct->handleTypes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo()
+safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkExportFenceCreateInfo::safe_VkExportFenceCreateInfo(const safe_VkExportFenceCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExportFenceCreateInfo& safe_VkExportFenceCreateInfo::operator=(const safe_VkExportFenceCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExportFenceCreateInfo::~safe_VkExportFenceCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportFenceCreateInfo::initialize(const VkExportFenceCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExportFenceCreateInfo::initialize(const safe_VkExportFenceCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleTypes = src->handleTypes;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleTypes(in_struct->handleTypes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo()
+safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkExportSemaphoreCreateInfo::safe_VkExportSemaphoreCreateInfo(const safe_VkExportSemaphoreCreateInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExportSemaphoreCreateInfo& safe_VkExportSemaphoreCreateInfo::operator=(const safe_VkExportSemaphoreCreateInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExportSemaphoreCreateInfo::~safe_VkExportSemaphoreCreateInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportSemaphoreCreateInfo::initialize(const VkExportSemaphoreCreateInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExportSemaphoreCreateInfo::initialize(const safe_VkExportSemaphoreCreateInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleTypes = src->handleTypes;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo()
+safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceExternalSemaphoreInfo::safe_VkPhysicalDeviceExternalSemaphoreInfo(const safe_VkPhysicalDeviceExternalSemaphoreInfo& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceExternalSemaphoreInfo& safe_VkPhysicalDeviceExternalSemaphoreInfo::operator=(const safe_VkPhysicalDeviceExternalSemaphoreInfo& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceExternalSemaphoreInfo::~safe_VkPhysicalDeviceExternalSemaphoreInfo()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const VkPhysicalDeviceExternalSemaphoreInfo* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceExternalSemaphoreInfo::initialize(const safe_VkPhysicalDeviceExternalSemaphoreInfo* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const VkExternalSemaphoreProperties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     exportFromImportedHandleTypes(in_struct->exportFromImportedHandleTypes),
     compatibleHandleTypes(in_struct->compatibleHandleTypes),
     externalSemaphoreFeatures(in_struct->externalSemaphoreFeatures)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties()
+safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalSemaphoreProperties::safe_VkExternalSemaphoreProperties(const safe_VkExternalSemaphoreProperties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     exportFromImportedHandleTypes = src.exportFromImportedHandleTypes;
     compatibleHandleTypes = src.compatibleHandleTypes;
     externalSemaphoreFeatures = src.externalSemaphoreFeatures;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalSemaphoreProperties& safe_VkExternalSemaphoreProperties::operator=(const safe_VkExternalSemaphoreProperties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     exportFromImportedHandleTypes = src.exportFromImportedHandleTypes;
     compatibleHandleTypes = src.compatibleHandleTypes;
     externalSemaphoreFeatures = src.externalSemaphoreFeatures;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalSemaphoreProperties::~safe_VkExternalSemaphoreProperties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalSemaphoreProperties::initialize(const VkExternalSemaphoreProperties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     exportFromImportedHandleTypes = in_struct->exportFromImportedHandleTypes;
     compatibleHandleTypes = in_struct->compatibleHandleTypes;
     externalSemaphoreFeatures = in_struct->externalSemaphoreFeatures;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalSemaphoreProperties::initialize(const safe_VkExternalSemaphoreProperties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     exportFromImportedHandleTypes = src->exportFromImportedHandleTypes;
     compatibleHandleTypes = src->compatibleHandleTypes;
     externalSemaphoreFeatures = src->externalSemaphoreFeatures;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties(const VkPhysicalDeviceMaintenance3Properties* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxPerSetDescriptors(in_struct->maxPerSetDescriptors),
     maxMemoryAllocationSize(in_struct->maxMemoryAllocationSize)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties()
+safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMaintenance3Properties::safe_VkPhysicalDeviceMaintenance3Properties(const safe_VkPhysicalDeviceMaintenance3Properties& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxPerSetDescriptors = src.maxPerSetDescriptors;
     maxMemoryAllocationSize = src.maxMemoryAllocationSize;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceMaintenance3Properties& safe_VkPhysicalDeviceMaintenance3Properties::operator=(const safe_VkPhysicalDeviceMaintenance3Properties& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxPerSetDescriptors = src.maxPerSetDescriptors;
     maxMemoryAllocationSize = src.maxMemoryAllocationSize;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceMaintenance3Properties::~safe_VkPhysicalDeviceMaintenance3Properties()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const VkPhysicalDeviceMaintenance3Properties* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxPerSetDescriptors = in_struct->maxPerSetDescriptors;
     maxMemoryAllocationSize = in_struct->maxMemoryAllocationSize;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceMaintenance3Properties::initialize(const safe_VkPhysicalDeviceMaintenance3Properties* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxPerSetDescriptors = src->maxPerSetDescriptors;
     maxMemoryAllocationSize = src->maxMemoryAllocationSize;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     supported(in_struct->supported)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport()
+safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport() :
+    pNext(nullptr)
 {}
 
 safe_VkDescriptorSetLayoutSupport::safe_VkDescriptorSetLayoutSupport(const safe_VkDescriptorSetLayoutSupport& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     supported = src.supported;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDescriptorSetLayoutSupport& safe_VkDescriptorSetLayoutSupport::operator=(const safe_VkDescriptorSetLayoutSupport& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     supported = src.supported;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDescriptorSetLayoutSupport::~safe_VkDescriptorSetLayoutSupport()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorSetLayoutSupport::initialize(const VkDescriptorSetLayoutSupport* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     supported = in_struct->supported;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDescriptorSetLayoutSupport::initialize(const safe_VkDescriptorSetLayoutSupport* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     supported = src->supported;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderDrawParameters(in_struct->shaderDrawParameters)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures()
+safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShaderDrawParametersFeatures::safe_VkPhysicalDeviceShaderDrawParametersFeatures(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderDrawParameters = src.shaderDrawParameters;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShaderDrawParametersFeatures& safe_VkPhysicalDeviceShaderDrawParametersFeatures::operator=(const safe_VkPhysicalDeviceShaderDrawParametersFeatures& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderDrawParameters = src.shaderDrawParameters;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShaderDrawParametersFeatures::~safe_VkPhysicalDeviceShaderDrawParametersFeatures()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(const VkPhysicalDeviceShaderDrawParametersFeatures* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderDrawParameters = in_struct->shaderDrawParameters;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShaderDrawParametersFeatures::initialize(const safe_VkPhysicalDeviceShaderDrawParametersFeatures* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderDrawParameters = src->shaderDrawParameters;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCreateInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     surface(in_struct->surface),
     minImageCount(in_struct->minImageCount),
@@ -9391,6 +10019,7 @@ safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCr
     clipped(in_struct->clipped),
     oldSwapchain(in_struct->oldSwapchain)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -9398,13 +10027,13 @@ safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const VkSwapchainCr
 }
 
 safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR() :
+    pNext(nullptr),
     pQueueFamilyIndices(nullptr)
 {}
 
 safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapchainCreateInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     surface = src.surface;
     minImageCount = src.minImageCount;
@@ -9421,6 +10050,7 @@ safe_VkSwapchainCreateInfoKHR::safe_VkSwapchainCreateInfoKHR(const safe_VkSwapch
     presentMode = src.presentMode;
     clipped = src.clipped;
     oldSwapchain = src.oldSwapchain;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -9433,9 +10063,10 @@ safe_VkSwapchainCreateInfoKHR& safe_VkSwapchainCreateInfoKHR::operator=(const sa
 
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     surface = src.surface;
     minImageCount = src.minImageCount;
@@ -9452,6 +10083,7 @@ safe_VkSwapchainCreateInfoKHR& safe_VkSwapchainCreateInfoKHR::operator=(const sa
     presentMode = src.presentMode;
     clipped = src.clipped;
     oldSwapchain = src.oldSwapchain;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -9464,12 +10096,13 @@ safe_VkSwapchainCreateInfoKHR::~safe_VkSwapchainCreateInfoKHR()
 {
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     surface = in_struct->surface;
     minImageCount = in_struct->minImageCount;
@@ -9486,6 +10119,7 @@ void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* i
     presentMode = in_struct->presentMode;
     clipped = in_struct->clipped;
     oldSwapchain = in_struct->oldSwapchain;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -9495,7 +10129,6 @@ void safe_VkSwapchainCreateInfoKHR::initialize(const VkSwapchainCreateInfoKHR* i
 void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     surface = src->surface;
     minImageCount = src->minImageCount;
@@ -9512,6 +10145,7 @@ void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoK
     presentMode = src->presentMode;
     clipped = src->clipped;
     oldSwapchain = src->oldSwapchain;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
@@ -9520,7 +10154,6 @@ void safe_VkSwapchainCreateInfoKHR::initialize(const safe_VkSwapchainCreateInfoK
 
 safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     waitSemaphoreCount(in_struct->waitSemaphoreCount),
     pWaitSemaphores(nullptr),
     swapchainCount(in_struct->swapchainCount),
@@ -9528,15 +10161,16 @@ safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct)
     pImageIndices(nullptr),
     pResults(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
         }
     }
     if (swapchainCount && in_struct->pSwapchains) {
         pSwapchains = new VkSwapchainKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pSwapchains[i] = in_struct->pSwapchains[i];
         }
     }
@@ -9551,6 +10185,7 @@ safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const VkPresentInfoKHR* in_struct)
 }
 
 safe_VkPresentInfoKHR::safe_VkPresentInfoKHR() :
+    pNext(nullptr),
     pWaitSemaphores(nullptr),
     pSwapchains(nullptr),
     pImageIndices(nullptr),
@@ -9560,22 +10195,22 @@ safe_VkPresentInfoKHR::safe_VkPresentInfoKHR() :
 safe_VkPresentInfoKHR::safe_VkPresentInfoKHR(const safe_VkPresentInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     swapchainCount = src.swapchainCount;
     pSwapchains = nullptr;
     pImageIndices = nullptr;
     pResults = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (waitSemaphoreCount && src.pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src.pWaitSemaphores[i];
         }
     }
     if (swapchainCount && src.pSwapchains) {
         pSwapchains = new VkSwapchainKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pSwapchains[i] = src.pSwapchains[i];
         }
     }
@@ -9601,24 +10236,26 @@ safe_VkPresentInfoKHR& safe_VkPresentInfoKHR::operator=(const safe_VkPresentInfo
         delete[] pImageIndices;
     if (pResults)
         delete[] pResults;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreCount = src.waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     swapchainCount = src.swapchainCount;
     pSwapchains = nullptr;
     pImageIndices = nullptr;
     pResults = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (waitSemaphoreCount && src.pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src.pWaitSemaphores[i];
         }
     }
     if (swapchainCount && src.pSwapchains) {
         pSwapchains = new VkSwapchainKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pSwapchains[i] = src.pSwapchains[i];
         }
     }
@@ -9644,27 +10281,29 @@ safe_VkPresentInfoKHR::~safe_VkPresentInfoKHR()
         delete[] pImageIndices;
     if (pResults)
         delete[] pResults;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPresentInfoKHR::initialize(const VkPresentInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     waitSemaphoreCount = in_struct->waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     swapchainCount = in_struct->swapchainCount;
     pSwapchains = nullptr;
     pImageIndices = nullptr;
     pResults = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (waitSemaphoreCount && in_struct->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = in_struct->pWaitSemaphores[i];
         }
     }
     if (swapchainCount && in_struct->pSwapchains) {
         pSwapchains = new VkSwapchainKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pSwapchains[i] = in_struct->pSwapchains[i];
         }
     }
@@ -9681,22 +10320,22 @@ void safe_VkPresentInfoKHR::initialize(const VkPresentInfoKHR* in_struct)
 void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     waitSemaphoreCount = src->waitSemaphoreCount;
     pWaitSemaphores = nullptr;
     swapchainCount = src->swapchainCount;
     pSwapchains = nullptr;
     pImageIndices = nullptr;
     pResults = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (waitSemaphoreCount && src->pWaitSemaphores) {
         pWaitSemaphores = new VkSemaphore[waitSemaphoreCount];
-        for (uint32_t i=0; i<waitSemaphoreCount; ++i) {
+        for (uint32_t i = 0; i < waitSemaphoreCount; ++i) {
             pWaitSemaphores[i] = src->pWaitSemaphores[i];
         }
     }
     if (swapchainCount && src->pSwapchains) {
         pSwapchains = new VkSwapchainKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pSwapchains[i] = src->pSwapchains[i];
         }
     }
@@ -9712,189 +10351,205 @@ void safe_VkPresentInfoKHR::initialize(const safe_VkPresentInfoKHR* src)
 
 safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const VkImageSwapchainCreateInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     swapchain(in_struct->swapchain)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR()
+safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkImageSwapchainCreateInfoKHR::safe_VkImageSwapchainCreateInfoKHR(const safe_VkImageSwapchainCreateInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     swapchain = src.swapchain;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageSwapchainCreateInfoKHR& safe_VkImageSwapchainCreateInfoKHR::operator=(const safe_VkImageSwapchainCreateInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     swapchain = src.swapchain;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageSwapchainCreateInfoKHR::~safe_VkImageSwapchainCreateInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageSwapchainCreateInfoKHR::initialize(const VkImageSwapchainCreateInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     swapchain = in_struct->swapchain;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageSwapchainCreateInfoKHR::initialize(const safe_VkImageSwapchainCreateInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     swapchain = src->swapchain;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(const VkBindImageMemorySwapchainInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     swapchain(in_struct->swapchain),
     imageIndex(in_struct->imageIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR()
+safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkBindImageMemorySwapchainInfoKHR::safe_VkBindImageMemorySwapchainInfoKHR(const safe_VkBindImageMemorySwapchainInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     swapchain = src.swapchain;
     imageIndex = src.imageIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBindImageMemorySwapchainInfoKHR& safe_VkBindImageMemorySwapchainInfoKHR::operator=(const safe_VkBindImageMemorySwapchainInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     swapchain = src.swapchain;
     imageIndex = src.imageIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBindImageMemorySwapchainInfoKHR::~safe_VkBindImageMemorySwapchainInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const VkBindImageMemorySwapchainInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     swapchain = in_struct->swapchain;
     imageIndex = in_struct->imageIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBindImageMemorySwapchainInfoKHR::initialize(const safe_VkBindImageMemorySwapchainInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     swapchain = src->swapchain;
     imageIndex = src->imageIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const VkAcquireNextImageInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     swapchain(in_struct->swapchain),
     timeout(in_struct->timeout),
     semaphore(in_struct->semaphore),
     fence(in_struct->fence),
     deviceMask(in_struct->deviceMask)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR()
+safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkAcquireNextImageInfoKHR::safe_VkAcquireNextImageInfoKHR(const safe_VkAcquireNextImageInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     swapchain = src.swapchain;
     timeout = src.timeout;
     semaphore = src.semaphore;
     fence = src.fence;
     deviceMask = src.deviceMask;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAcquireNextImageInfoKHR& safe_VkAcquireNextImageInfoKHR::operator=(const safe_VkAcquireNextImageInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     swapchain = src.swapchain;
     timeout = src.timeout;
     semaphore = src.semaphore;
     fence = src.fence;
     deviceMask = src.deviceMask;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAcquireNextImageInfoKHR::~safe_VkAcquireNextImageInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAcquireNextImageInfoKHR::initialize(const VkAcquireNextImageInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     swapchain = in_struct->swapchain;
     timeout = in_struct->timeout;
     semaphore = in_struct->semaphore;
     fence = in_struct->fence;
     deviceMask = in_struct->deviceMask;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAcquireNextImageInfoKHR::initialize(const safe_VkAcquireNextImageInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     swapchain = src->swapchain;
     timeout = src->timeout;
     semaphore = src->semaphore;
     fence = src->fence;
     deviceMask = src->deviceMask;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(const VkDeviceGroupPresentCapabilitiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     modes(in_struct->modes)
 {
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         presentMask[i] = in_struct->presentMask[i];
     }
 }
 
-safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR()
+safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceGroupPresentCapabilitiesKHR::safe_VkDeviceGroupPresentCapabilitiesKHR(const safe_VkDeviceGroupPresentCapabilitiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     modes = src.modes;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         presentMask[i] = src.presentMask[i];
     }
 }
@@ -9903,11 +10558,13 @@ safe_VkDeviceGroupPresentCapabilitiesKHR& safe_VkDeviceGroupPresentCapabilitiesK
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     modes = src.modes;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         presentMask[i] = src.presentMask[i];
     }
 
@@ -9916,14 +10573,16 @@ safe_VkDeviceGroupPresentCapabilitiesKHR& safe_VkDeviceGroupPresentCapabilitiesK
 
 safe_VkDeviceGroupPresentCapabilitiesKHR::~safe_VkDeviceGroupPresentCapabilitiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const VkDeviceGroupPresentCapabilitiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     modes = in_struct->modes;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         presentMask[i] = in_struct->presentMask[i];
     }
 }
@@ -9931,20 +10590,20 @@ void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const VkDeviceGroupPre
 void safe_VkDeviceGroupPresentCapabilitiesKHR::initialize(const safe_VkDeviceGroupPresentCapabilitiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     modes = src->modes;
-    for (uint32_t i=0; i<VK_MAX_DEVICE_GROUP_SIZE; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DEVICE_GROUP_SIZE; ++i) {
         presentMask[i] = src->presentMask[i];
     }
 }
 
 safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const VkDeviceGroupPresentInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     swapchainCount(in_struct->swapchainCount),
     pDeviceMasks(nullptr),
     mode(in_struct->mode)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceMasks) {
         pDeviceMasks = new uint32_t[in_struct->swapchainCount];
         memcpy ((void *)pDeviceMasks, (void *)in_struct->pDeviceMasks, sizeof(uint32_t)*in_struct->swapchainCount);
@@ -9952,16 +10611,17 @@ safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const VkDevic
 }
 
 safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR() :
+    pNext(nullptr),
     pDeviceMasks(nullptr)
 {}
 
 safe_VkDeviceGroupPresentInfoKHR::safe_VkDeviceGroupPresentInfoKHR(const safe_VkDeviceGroupPresentInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     swapchainCount = src.swapchainCount;
     pDeviceMasks = nullptr;
     mode = src.mode;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceMasks) {
         pDeviceMasks = new uint32_t[src.swapchainCount];
         memcpy ((void *)pDeviceMasks, (void *)src.pDeviceMasks, sizeof(uint32_t)*src.swapchainCount);
@@ -9974,12 +10634,14 @@ safe_VkDeviceGroupPresentInfoKHR& safe_VkDeviceGroupPresentInfoKHR::operator=(co
 
     if (pDeviceMasks)
         delete[] pDeviceMasks;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     swapchainCount = src.swapchainCount;
     pDeviceMasks = nullptr;
     mode = src.mode;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceMasks) {
         pDeviceMasks = new uint32_t[src.swapchainCount];
         memcpy ((void *)pDeviceMasks, (void *)src.pDeviceMasks, sizeof(uint32_t)*src.swapchainCount);
@@ -9992,15 +10654,17 @@ safe_VkDeviceGroupPresentInfoKHR::~safe_VkDeviceGroupPresentInfoKHR()
 {
     if (pDeviceMasks)
         delete[] pDeviceMasks;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupPresentInfoKHR::initialize(const VkDeviceGroupPresentInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     swapchainCount = in_struct->swapchainCount;
     pDeviceMasks = nullptr;
     mode = in_struct->mode;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceMasks) {
         pDeviceMasks = new uint32_t[in_struct->swapchainCount];
         memcpy ((void *)pDeviceMasks, (void *)in_struct->pDeviceMasks, sizeof(uint32_t)*in_struct->swapchainCount);
@@ -10010,10 +10674,10 @@ void safe_VkDeviceGroupPresentInfoKHR::initialize(const VkDeviceGroupPresentInfo
 void safe_VkDeviceGroupPresentInfoKHR::initialize(const safe_VkDeviceGroupPresentInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     swapchainCount = src->swapchainCount;
     pDeviceMasks = nullptr;
     mode = src->mode;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDeviceMasks) {
         pDeviceMasks = new uint32_t[src->swapchainCount];
         memcpy ((void *)pDeviceMasks, (void *)src->pDeviceMasks, sizeof(uint32_t)*src->swapchainCount);
@@ -10022,173 +10686,185 @@ void safe_VkDeviceGroupPresentInfoKHR::initialize(const safe_VkDeviceGroupPresen
 
 safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     modes(in_struct->modes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR()
+safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceGroupSwapchainCreateInfoKHR::safe_VkDeviceGroupSwapchainCreateInfoKHR(const safe_VkDeviceGroupSwapchainCreateInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     modes = src.modes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceGroupSwapchainCreateInfoKHR& safe_VkDeviceGroupSwapchainCreateInfoKHR::operator=(const safe_VkDeviceGroupSwapchainCreateInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     modes = src.modes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceGroupSwapchainCreateInfoKHR::~safe_VkDeviceGroupSwapchainCreateInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const VkDeviceGroupSwapchainCreateInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     modes = in_struct->modes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceGroupSwapchainCreateInfoKHR::initialize(const safe_VkDeviceGroupSwapchainCreateInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     modes = src->modes;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const VkDisplayPropertiesKHR* in_struct) :
     display(in_struct->display),
-    displayName(in_struct->displayName),
     physicalDimensions(in_struct->physicalDimensions),
     physicalResolution(in_struct->physicalResolution),
     supportedTransforms(in_struct->supportedTransforms),
     planeReorderPossible(in_struct->planeReorderPossible),
     persistentContent(in_struct->persistentContent)
 {
+    displayName = SafeStringCopy(in_struct->displayName);
 }
 
-safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR()
+safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR() :
+    displayName(nullptr)
 {}
 
 safe_VkDisplayPropertiesKHR::safe_VkDisplayPropertiesKHR(const safe_VkDisplayPropertiesKHR& src)
 {
     display = src.display;
-    displayName = src.displayName;
     physicalDimensions = src.physicalDimensions;
     physicalResolution = src.physicalResolution;
     supportedTransforms = src.supportedTransforms;
     planeReorderPossible = src.planeReorderPossible;
     persistentContent = src.persistentContent;
+    displayName = SafeStringCopy(src.displayName);
 }
 
 safe_VkDisplayPropertiesKHR& safe_VkDisplayPropertiesKHR::operator=(const safe_VkDisplayPropertiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (displayName) delete [] displayName;
 
     display = src.display;
-    displayName = src.displayName;
     physicalDimensions = src.physicalDimensions;
     physicalResolution = src.physicalResolution;
     supportedTransforms = src.supportedTransforms;
     planeReorderPossible = src.planeReorderPossible;
     persistentContent = src.persistentContent;
+    displayName = SafeStringCopy(src.displayName);
 
     return *this;
 }
 
 safe_VkDisplayPropertiesKHR::~safe_VkDisplayPropertiesKHR()
 {
+    if (displayName) delete [] displayName;
 }
 
 void safe_VkDisplayPropertiesKHR::initialize(const VkDisplayPropertiesKHR* in_struct)
 {
     display = in_struct->display;
-    displayName = in_struct->displayName;
     physicalDimensions = in_struct->physicalDimensions;
     physicalResolution = in_struct->physicalResolution;
     supportedTransforms = in_struct->supportedTransforms;
     planeReorderPossible = in_struct->planeReorderPossible;
     persistentContent = in_struct->persistentContent;
+    displayName = SafeStringCopy(in_struct->displayName);
 }
 
 void safe_VkDisplayPropertiesKHR::initialize(const safe_VkDisplayPropertiesKHR* src)
 {
     display = src->display;
-    displayName = src->displayName;
     physicalDimensions = src->physicalDimensions;
     physicalResolution = src->physicalResolution;
     supportedTransforms = src->supportedTransforms;
     planeReorderPossible = src->planeReorderPossible;
     persistentContent = src->persistentContent;
+    displayName = SafeStringCopy(src->displayName);
 }
 
 safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const VkDisplayModeCreateInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     parameters(in_struct->parameters)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR()
+safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayModeCreateInfoKHR::safe_VkDisplayModeCreateInfoKHR(const safe_VkDisplayModeCreateInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     parameters = src.parameters;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayModeCreateInfoKHR& safe_VkDisplayModeCreateInfoKHR::operator=(const safe_VkDisplayModeCreateInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     parameters = src.parameters;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayModeCreateInfoKHR::~safe_VkDisplayModeCreateInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayModeCreateInfoKHR::initialize(const VkDisplayModeCreateInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     parameters = in_struct->parameters;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayModeCreateInfoKHR::initialize(const safe_VkDisplayModeCreateInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     parameters = src->parameters;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const VkDisplaySurfaceCreateInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     displayMode(in_struct->displayMode),
     planeIndex(in_struct->planeIndex),
@@ -10198,15 +10874,16 @@ safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const VkD
     alphaMode(in_struct->alphaMode),
     imageExtent(in_struct->imageExtent)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR()
+safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const safe_VkDisplaySurfaceCreateInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     displayMode = src.displayMode;
     planeIndex = src.planeIndex;
@@ -10215,15 +10892,17 @@ safe_VkDisplaySurfaceCreateInfoKHR::safe_VkDisplaySurfaceCreateInfoKHR(const saf
     globalAlpha = src.globalAlpha;
     alphaMode = src.alphaMode;
     imageExtent = src.imageExtent;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplaySurfaceCreateInfoKHR& safe_VkDisplaySurfaceCreateInfoKHR::operator=(const safe_VkDisplaySurfaceCreateInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     displayMode = src.displayMode;
     planeIndex = src.planeIndex;
@@ -10232,18 +10911,20 @@ safe_VkDisplaySurfaceCreateInfoKHR& safe_VkDisplaySurfaceCreateInfoKHR::operator
     globalAlpha = src.globalAlpha;
     alphaMode = src.alphaMode;
     imageExtent = src.imageExtent;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplaySurfaceCreateInfoKHR::~safe_VkDisplaySurfaceCreateInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const VkDisplaySurfaceCreateInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     displayMode = in_struct->displayMode;
     planeIndex = in_struct->planeIndex;
@@ -10252,12 +10933,12 @@ void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const VkDisplaySurfaceCreate
     globalAlpha = in_struct->globalAlpha;
     alphaMode = in_struct->alphaMode;
     imageExtent = in_struct->imageExtent;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceCreateInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     displayMode = src->displayMode;
     planeIndex = src->planeIndex;
@@ -10266,122 +10947,133 @@ void safe_VkDisplaySurfaceCreateInfoKHR::initialize(const safe_VkDisplaySurfaceC
     globalAlpha = src->globalAlpha;
     alphaMode = src->alphaMode;
     imageExtent = src->imageExtent;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const VkDisplayPresentInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     srcRect(in_struct->srcRect),
     dstRect(in_struct->dstRect),
     persistent(in_struct->persistent)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR()
+safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayPresentInfoKHR::safe_VkDisplayPresentInfoKHR(const safe_VkDisplayPresentInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     srcRect = src.srcRect;
     dstRect = src.dstRect;
     persistent = src.persistent;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayPresentInfoKHR& safe_VkDisplayPresentInfoKHR::operator=(const safe_VkDisplayPresentInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     srcRect = src.srcRect;
     dstRect = src.dstRect;
     persistent = src.persistent;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayPresentInfoKHR::~safe_VkDisplayPresentInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayPresentInfoKHR::initialize(const VkDisplayPresentInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     srcRect = in_struct->srcRect;
     dstRect = in_struct->dstRect;
     persistent = in_struct->persistent;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayPresentInfoKHR::initialize(const safe_VkDisplayPresentInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     srcRect = src->srcRect;
     dstRect = src->dstRect;
     persistent = src->persistent;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const VkImportMemoryWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleType(in_struct->handleType),
     handle(in_struct->handle),
     name(in_struct->name)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR()
+safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkImportMemoryWin32HandleInfoKHR::safe_VkImportMemoryWin32HandleInfoKHR(const safe_VkImportMemoryWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     handle = src.handle;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportMemoryWin32HandleInfoKHR& safe_VkImportMemoryWin32HandleInfoKHR::operator=(const safe_VkImportMemoryWin32HandleInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     handle = src.handle;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportMemoryWin32HandleInfoKHR::~safe_VkImportMemoryWin32HandleInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const VkImportMemoryWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleType = in_struct->handleType;
     handle = in_struct->handle;
     name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemoryWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleType = src->handleType;
     handle = src->handle;
     name = src->name;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -10390,27 +11082,28 @@ void safe_VkImportMemoryWin32HandleInfoKHR::initialize(const safe_VkImportMemory
 
 safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const VkExportMemoryWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pAttributes(nullptr),
     dwAccess(in_struct->dwAccess),
     name(in_struct->name)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
 }
 
 safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR() :
+    pNext(nullptr),
     pAttributes(nullptr)
 {}
 
 safe_VkExportMemoryWin32HandleInfoKHR::safe_VkExportMemoryWin32HandleInfoKHR(const safe_VkExportMemoryWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -10422,12 +11115,14 @@ safe_VkExportMemoryWin32HandleInfoKHR& safe_VkExportMemoryWin32HandleInfoKHR::op
 
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -10439,15 +11134,17 @@ safe_VkExportMemoryWin32HandleInfoKHR::~safe_VkExportMemoryWin32HandleInfoKHR()
 {
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pAttributes = nullptr;
     dwAccess = in_struct->dwAccess;
     name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
@@ -10456,10 +11153,10 @@ void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const VkExportMemoryWin32
 void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemoryWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pAttributes = nullptr;
     dwAccess = src->dwAccess;
     name = src->name;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
     }
@@ -10471,49 +11168,54 @@ void safe_VkExportMemoryWin32HandleInfoKHR::initialize(const safe_VkExportMemory
 
 safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const VkMemoryWin32HandlePropertiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memoryTypeBits(in_struct->memoryTypeBits)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR()
+safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryWin32HandlePropertiesKHR::safe_VkMemoryWin32HandlePropertiesKHR(const safe_VkMemoryWin32HandlePropertiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryWin32HandlePropertiesKHR& safe_VkMemoryWin32HandlePropertiesKHR::operator=(const safe_VkMemoryWin32HandlePropertiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryWin32HandlePropertiesKHR::~safe_VkMemoryWin32HandlePropertiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const VkMemoryWin32HandlePropertiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32HandlePropertiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memoryTypeBits = src->memoryTypeBits;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -10522,214 +11224,233 @@ void safe_VkMemoryWin32HandlePropertiesKHR::initialize(const safe_VkMemoryWin32H
 
 safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const VkMemoryGetWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memory(in_struct->memory),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR()
+safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryGetWin32HandleInfoKHR::safe_VkMemoryGetWin32HandleInfoKHR(const safe_VkMemoryGetWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryGetWin32HandleInfoKHR& safe_VkMemoryGetWin32HandleInfoKHR::operator=(const safe_VkMemoryGetWin32HandleInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryGetWin32HandleInfoKHR::~safe_VkMemoryGetWin32HandleInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const VkMemoryGetWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memory = in_struct->memory;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryGetWin32HandleInfoKHR::initialize(const safe_VkMemoryGetWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memory = src->memory;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const VkImportMemoryFdInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleType(in_struct->handleType),
     fd(in_struct->fd)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR()
+safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkImportMemoryFdInfoKHR::safe_VkImportMemoryFdInfoKHR(const safe_VkImportMemoryFdInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     fd = src.fd;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportMemoryFdInfoKHR& safe_VkImportMemoryFdInfoKHR::operator=(const safe_VkImportMemoryFdInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     fd = src.fd;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportMemoryFdInfoKHR::~safe_VkImportMemoryFdInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportMemoryFdInfoKHR::initialize(const VkImportMemoryFdInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleType = in_struct->handleType;
     fd = in_struct->fd;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportMemoryFdInfoKHR::initialize(const safe_VkImportMemoryFdInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleType = src->handleType;
     fd = src->fd;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const VkMemoryFdPropertiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memoryTypeBits(in_struct->memoryTypeBits)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR()
+safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryFdPropertiesKHR::safe_VkMemoryFdPropertiesKHR(const safe_VkMemoryFdPropertiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryFdPropertiesKHR& safe_VkMemoryFdPropertiesKHR::operator=(const safe_VkMemoryFdPropertiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryFdPropertiesKHR::~safe_VkMemoryFdPropertiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryFdPropertiesKHR::initialize(const VkMemoryFdPropertiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryFdPropertiesKHR::initialize(const safe_VkMemoryFdPropertiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memoryTypeBits = src->memoryTypeBits;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const VkMemoryGetFdInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memory(in_struct->memory),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR()
+safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryGetFdInfoKHR::safe_VkMemoryGetFdInfoKHR(const safe_VkMemoryGetFdInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryGetFdInfoKHR& safe_VkMemoryGetFdInfoKHR::operator=(const safe_VkMemoryGetFdInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryGetFdInfoKHR::~safe_VkMemoryGetFdInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryGetFdInfoKHR::initialize(const VkMemoryGetFdInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memory = in_struct->memory;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryGetFdInfoKHR::initialize(const safe_VkMemoryGetFdInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memory = src->memory;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     acquireCount(in_struct->acquireCount),
     pAcquireSyncs(nullptr),
     pAcquireKeys(nullptr),
@@ -10738,9 +11459,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleas
     pReleaseSyncs(nullptr),
     pReleaseKeys(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (acquireCount && in_struct->pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
         }
     }
@@ -10754,7 +11476,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleas
     }
     if (releaseCount && in_struct->pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
         }
     }
@@ -10765,6 +11487,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleas
 }
 
 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR() :
+    pNext(nullptr),
     pAcquireSyncs(nullptr),
     pAcquireKeys(nullptr),
     pAcquireTimeouts(nullptr),
@@ -10775,7 +11498,6 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleas
 safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     acquireCount = src.acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -10783,9 +11505,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleas
     releaseCount = src.releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (acquireCount && src.pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = src.pAcquireSyncs[i];
         }
     }
@@ -10799,7 +11522,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::safe_VkWin32KeyedMutexAcquireReleas
     }
     if (releaseCount && src.pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = src.pReleaseSyncs[i];
         }
     }
@@ -10823,9 +11546,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleas
         delete[] pReleaseSyncs;
     if (pReleaseKeys)
         delete[] pReleaseKeys;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     acquireCount = src.acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -10833,9 +11557,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleas
     releaseCount = src.releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (acquireCount && src.pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = src.pAcquireSyncs[i];
         }
     }
@@ -10849,7 +11574,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR& safe_VkWin32KeyedMutexAcquireReleas
     }
     if (releaseCount && src.pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = src.pReleaseSyncs[i];
         }
     }
@@ -10873,12 +11598,13 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::~safe_VkWin32KeyedMutexAcquireRelea
         delete[] pReleaseSyncs;
     if (pReleaseKeys)
         delete[] pReleaseKeys;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedMutexAcquireReleaseInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     acquireCount = in_struct->acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -10886,9 +11612,10 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedM
     releaseCount = in_struct->releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (acquireCount && in_struct->pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
         }
     }
@@ -10902,7 +11629,7 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedM
     }
     if (releaseCount && in_struct->pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
         }
     }
@@ -10915,7 +11642,6 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const VkWin32KeyedM
 void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     acquireCount = src->acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -10923,9 +11649,10 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32K
     releaseCount = src->releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (acquireCount && src->pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = src->pAcquireSyncs[i];
         }
     }
@@ -10939,7 +11666,7 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32K
     }
     if (releaseCount && src->pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = src->pReleaseSyncs[i];
         }
     }
@@ -10955,69 +11682,74 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoKHR::initialize(const safe_VkWin32K
 
 safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(const VkImportSemaphoreWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     semaphore(in_struct->semaphore),
     flags(in_struct->flags),
     handleType(in_struct->handleType),
     handle(in_struct->handle),
     name(in_struct->name)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR()
+safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkImportSemaphoreWin32HandleInfoKHR::safe_VkImportSemaphoreWin32HandleInfoKHR(const safe_VkImportSemaphoreWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     flags = src.flags;
     handleType = src.handleType;
     handle = src.handle;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportSemaphoreWin32HandleInfoKHR& safe_VkImportSemaphoreWin32HandleInfoKHR::operator=(const safe_VkImportSemaphoreWin32HandleInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     flags = src.flags;
     handleType = src.handleType;
     handle = src.handle;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportSemaphoreWin32HandleInfoKHR::~safe_VkImportSemaphoreWin32HandleInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const VkImportSemaphoreWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     semaphore = in_struct->semaphore;
     flags = in_struct->flags;
     handleType = in_struct->handleType;
     handle = in_struct->handle;
     name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSemaphoreWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     semaphore = src->semaphore;
     flags = src->flags;
     handleType = src->handleType;
     handle = src->handle;
     name = src->name;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -11026,27 +11758,28 @@ void safe_VkImportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkImportSem
 
 safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(const VkExportSemaphoreWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pAttributes(nullptr),
     dwAccess(in_struct->dwAccess),
     name(in_struct->name)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
 }
 
 safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR() :
+    pNext(nullptr),
     pAttributes(nullptr)
 {}
 
 safe_VkExportSemaphoreWin32HandleInfoKHR::safe_VkExportSemaphoreWin32HandleInfoKHR(const safe_VkExportSemaphoreWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -11058,12 +11791,14 @@ safe_VkExportSemaphoreWin32HandleInfoKHR& safe_VkExportSemaphoreWin32HandleInfoK
 
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -11075,15 +11810,17 @@ safe_VkExportSemaphoreWin32HandleInfoKHR::~safe_VkExportSemaphoreWin32HandleInfo
 {
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphoreWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pAttributes = nullptr;
     dwAccess = in_struct->dwAccess;
     name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
@@ -11092,10 +11829,10 @@ void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const VkExportSemaphor
 void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSemaphoreWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pAttributes = nullptr;
     dwAccess = src->dwAccess;
     name = src->name;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
     }
@@ -11107,12 +11844,12 @@ void safe_VkExportSemaphoreWin32HandleInfoKHR::initialize(const safe_VkExportSem
 
 safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12FenceSubmitInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     waitSemaphoreValuesCount(in_struct->waitSemaphoreValuesCount),
     pWaitSemaphoreValues(nullptr),
     signalSemaphoreValuesCount(in_struct->signalSemaphoreValuesCount),
     pSignalSemaphoreValues(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pWaitSemaphoreValues) {
         pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
         memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValuesCount);
@@ -11124,6 +11861,7 @@ safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const VkD3D12Fenc
 }
 
 safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR() :
+    pNext(nullptr),
     pWaitSemaphoreValues(nullptr),
     pSignalSemaphoreValues(nullptr)
 {}
@@ -11131,11 +11869,11 @@ safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR() :
 safe_VkD3D12FenceSubmitInfoKHR::safe_VkD3D12FenceSubmitInfoKHR(const safe_VkD3D12FenceSubmitInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreValuesCount = src.waitSemaphoreValuesCount;
     pWaitSemaphoreValues = nullptr;
     signalSemaphoreValuesCount = src.signalSemaphoreValuesCount;
     pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pWaitSemaphoreValues) {
         pWaitSemaphoreValues = new uint64_t[src.waitSemaphoreValuesCount];
         memcpy ((void *)pWaitSemaphoreValues, (void *)src.pWaitSemaphoreValues, sizeof(uint64_t)*src.waitSemaphoreValuesCount);
@@ -11154,13 +11892,15 @@ safe_VkD3D12FenceSubmitInfoKHR& safe_VkD3D12FenceSubmitInfoKHR::operator=(const
         delete[] pWaitSemaphoreValues;
     if (pSignalSemaphoreValues)
         delete[] pSignalSemaphoreValues;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     waitSemaphoreValuesCount = src.waitSemaphoreValuesCount;
     pWaitSemaphoreValues = nullptr;
     signalSemaphoreValuesCount = src.signalSemaphoreValuesCount;
     pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pWaitSemaphoreValues) {
         pWaitSemaphoreValues = new uint64_t[src.waitSemaphoreValuesCount];
         memcpy ((void *)pWaitSemaphoreValues, (void *)src.pWaitSemaphoreValues, sizeof(uint64_t)*src.waitSemaphoreValuesCount);
@@ -11179,16 +11919,18 @@ safe_VkD3D12FenceSubmitInfoKHR::~safe_VkD3D12FenceSubmitInfoKHR()
         delete[] pWaitSemaphoreValues;
     if (pSignalSemaphoreValues)
         delete[] pSignalSemaphoreValues;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     waitSemaphoreValuesCount = in_struct->waitSemaphoreValuesCount;
     pWaitSemaphoreValues = nullptr;
     signalSemaphoreValuesCount = in_struct->signalSemaphoreValuesCount;
     pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pWaitSemaphoreValues) {
         pWaitSemaphoreValues = new uint64_t[in_struct->waitSemaphoreValuesCount];
         memcpy ((void *)pWaitSemaphoreValues, (void *)in_struct->pWaitSemaphoreValues, sizeof(uint64_t)*in_struct->waitSemaphoreValuesCount);
@@ -11202,11 +11944,11 @@ void safe_VkD3D12FenceSubmitInfoKHR::initialize(const VkD3D12FenceSubmitInfoKHR*
 void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     waitSemaphoreValuesCount = src->waitSemaphoreValuesCount;
     pWaitSemaphoreValues = nullptr;
     signalSemaphoreValuesCount = src->signalSemaphoreValuesCount;
     pSignalSemaphoreValues = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pWaitSemaphoreValues) {
         pWaitSemaphoreValues = new uint64_t[src->waitSemaphoreValuesCount];
         memcpy ((void *)pWaitSemaphoreValues, (void *)src->pWaitSemaphoreValues, sizeof(uint64_t)*src->waitSemaphoreValuesCount);
@@ -11223,269 +11965,294 @@ void safe_VkD3D12FenceSubmitInfoKHR::initialize(const safe_VkD3D12FenceSubmitInf
 
 safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const VkSemaphoreGetWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     semaphore(in_struct->semaphore),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR()
+safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSemaphoreGetWin32HandleInfoKHR::safe_VkSemaphoreGetWin32HandleInfoKHR(const safe_VkSemaphoreGetWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSemaphoreGetWin32HandleInfoKHR& safe_VkSemaphoreGetWin32HandleInfoKHR::operator=(const safe_VkSemaphoreGetWin32HandleInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSemaphoreGetWin32HandleInfoKHR::~safe_VkSemaphoreGetWin32HandleInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const VkSemaphoreGetWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     semaphore = in_struct->semaphore;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSemaphoreGetWin32HandleInfoKHR::initialize(const safe_VkSemaphoreGetWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     semaphore = src->semaphore;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const VkImportSemaphoreFdInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     semaphore(in_struct->semaphore),
     flags(in_struct->flags),
     handleType(in_struct->handleType),
     fd(in_struct->fd)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR()
+safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkImportSemaphoreFdInfoKHR::safe_VkImportSemaphoreFdInfoKHR(const safe_VkImportSemaphoreFdInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     flags = src.flags;
     handleType = src.handleType;
     fd = src.fd;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportSemaphoreFdInfoKHR& safe_VkImportSemaphoreFdInfoKHR::operator=(const safe_VkImportSemaphoreFdInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     flags = src.flags;
     handleType = src.handleType;
     fd = src.fd;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportSemaphoreFdInfoKHR::~safe_VkImportSemaphoreFdInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportSemaphoreFdInfoKHR::initialize(const VkImportSemaphoreFdInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     semaphore = in_struct->semaphore;
     flags = in_struct->flags;
     handleType = in_struct->handleType;
     fd = in_struct->fd;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportSemaphoreFdInfoKHR::initialize(const safe_VkImportSemaphoreFdInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     semaphore = src->semaphore;
     flags = src->flags;
     handleType = src->handleType;
     fd = src->fd;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const VkSemaphoreGetFdInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     semaphore(in_struct->semaphore),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR()
+safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSemaphoreGetFdInfoKHR::safe_VkSemaphoreGetFdInfoKHR(const safe_VkSemaphoreGetFdInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSemaphoreGetFdInfoKHR& safe_VkSemaphoreGetFdInfoKHR::operator=(const safe_VkSemaphoreGetFdInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     semaphore = src.semaphore;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSemaphoreGetFdInfoKHR::~safe_VkSemaphoreGetFdInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSemaphoreGetFdInfoKHR::initialize(const VkSemaphoreGetFdInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     semaphore = in_struct->semaphore;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSemaphoreGetFdInfoKHR::initialize(const safe_VkSemaphoreGetFdInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     semaphore = src->semaphore;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxPushDescriptors(in_struct->maxPushDescriptors)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
+safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDevicePushDescriptorPropertiesKHR::safe_VkPhysicalDevicePushDescriptorPropertiesKHR(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxPushDescriptors = src.maxPushDescriptors;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDevicePushDescriptorPropertiesKHR& safe_VkPhysicalDevicePushDescriptorPropertiesKHR::operator=(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxPushDescriptors = src.maxPushDescriptors;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDevicePushDescriptorPropertiesKHR::~safe_VkPhysicalDevicePushDescriptorPropertiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const VkPhysicalDevicePushDescriptorPropertiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxPushDescriptors = in_struct->maxPushDescriptors;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDevicePushDescriptorPropertiesKHR::initialize(const safe_VkPhysicalDevicePushDescriptorPropertiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxPushDescriptors = src->maxPushDescriptors;
+    pNext = SafePnextCopy(src->pNext);
 }
 
-safe_VkPhysicalDeviceFloat16Int8FeaturesKHR::safe_VkPhysicalDeviceFloat16Int8FeaturesKHR(const VkPhysicalDeviceFloat16Int8FeaturesKHR* in_struct) :
+safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR::safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderFloat16(in_struct->shaderFloat16),
     shaderInt8(in_struct->shaderInt8)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceFloat16Int8FeaturesKHR::safe_VkPhysicalDeviceFloat16Int8FeaturesKHR()
+safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR::safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR() :
+    pNext(nullptr)
 {}
 
-safe_VkPhysicalDeviceFloat16Int8FeaturesKHR::safe_VkPhysicalDeviceFloat16Int8FeaturesKHR(const safe_VkPhysicalDeviceFloat16Int8FeaturesKHR& src)
+safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR::safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderFloat16 = src.shaderFloat16;
     shaderInt8 = src.shaderInt8;
+    pNext = SafePnextCopy(src.pNext);
 }
 
-safe_VkPhysicalDeviceFloat16Int8FeaturesKHR& safe_VkPhysicalDeviceFloat16Int8FeaturesKHR::operator=(const safe_VkPhysicalDeviceFloat16Int8FeaturesKHR& src)
+safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR::operator=(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderFloat16 = src.shaderFloat16;
     shaderInt8 = src.shaderInt8;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
-safe_VkPhysicalDeviceFloat16Int8FeaturesKHR::~safe_VkPhysicalDeviceFloat16Int8FeaturesKHR()
+safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR::~safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
-void safe_VkPhysicalDeviceFloat16Int8FeaturesKHR::initialize(const VkPhysicalDeviceFloat16Int8FeaturesKHR* in_struct)
+void safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR::initialize(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderFloat16 = in_struct->shaderFloat16;
     shaderInt8 = in_struct->shaderInt8;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-void safe_VkPhysicalDeviceFloat16Int8FeaturesKHR::initialize(const safe_VkPhysicalDeviceFloat16Int8FeaturesKHR* src)
+void safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderFloat16 = src->shaderFloat16;
     shaderInt8 = src->shaderInt8;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPresentRegionKHR::safe_VkPresentRegionKHR(const VkPresentRegionKHR* in_struct) :
@@ -11557,31 +12324,32 @@ void safe_VkPresentRegionKHR::initialize(const safe_VkPresentRegionKHR* src)
 
 safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const VkPresentRegionsKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     swapchainCount(in_struct->swapchainCount),
     pRegions(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (swapchainCount && in_struct->pRegions) {
         pRegions = new safe_VkPresentRegionKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pRegions[i].initialize(&in_struct->pRegions[i]);
         }
     }
 }
 
 safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR() :
+    pNext(nullptr),
     pRegions(nullptr)
 {}
 
 safe_VkPresentRegionsKHR::safe_VkPresentRegionsKHR(const safe_VkPresentRegionsKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     swapchainCount = src.swapchainCount;
     pRegions = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (swapchainCount && src.pRegions) {
         pRegions = new safe_VkPresentRegionKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pRegions[i].initialize(&src.pRegions[i]);
         }
     }
@@ -11593,14 +12361,16 @@ safe_VkPresentRegionsKHR& safe_VkPresentRegionsKHR::operator=(const safe_VkPrese
 
     if (pRegions)
         delete[] pRegions;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     swapchainCount = src.swapchainCount;
     pRegions = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (swapchainCount && src.pRegions) {
         pRegions = new safe_VkPresentRegionKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pRegions[i].initialize(&src.pRegions[i]);
         }
     }
@@ -11612,17 +12382,19 @@ safe_VkPresentRegionsKHR::~safe_VkPresentRegionsKHR()
 {
     if (pRegions)
         delete[] pRegions;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     swapchainCount = in_struct->swapchainCount;
     pRegions = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (swapchainCount && in_struct->pRegions) {
         pRegions = new safe_VkPresentRegionKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pRegions[i].initialize(&in_struct->pRegions[i]);
         }
     }
@@ -11631,12 +12403,12 @@ void safe_VkPresentRegionsKHR::initialize(const VkPresentRegionsKHR* in_struct)
 void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     swapchainCount = src->swapchainCount;
     pRegions = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (swapchainCount && src->pRegions) {
         pRegions = new safe_VkPresentRegionKHR[swapchainCount];
-        for (uint32_t i=0; i<swapchainCount; ++i) {
+        for (uint32_t i = 0; i < swapchainCount; ++i) {
             pRegions[i].initialize(&src->pRegions[i]);
         }
     }
@@ -11644,54 +12416,58 @@ void safe_VkPresentRegionsKHR::initialize(const safe_VkPresentRegionsKHR* src)
 
 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(const VkPhysicalDeviceImagelessFramebufferFeaturesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     imagelessFramebuffer(in_struct->imagelessFramebuffer)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR()
+safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     imagelessFramebuffer = src.imagelessFramebuffer;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::operator=(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     imagelessFramebuffer = src.imagelessFramebuffer;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::~safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::initialize(const VkPhysicalDeviceImagelessFramebufferFeaturesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     imagelessFramebuffer = in_struct->imagelessFramebuffer;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR::initialize(const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     imagelessFramebuffer = src->imagelessFramebuffer;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkFramebufferAttachmentImageInfoKHR::safe_VkFramebufferAttachmentImageInfoKHR(const VkFramebufferAttachmentImageInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     usage(in_struct->usage),
     width(in_struct->width),
@@ -11700,6 +12476,7 @@ safe_VkFramebufferAttachmentImageInfoKHR::safe_VkFramebufferAttachmentImageInfoK
     viewFormatCount(in_struct->viewFormatCount),
     pViewFormats(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewFormats) {
         pViewFormats = new VkFormat[in_struct->viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
@@ -11707,13 +12484,13 @@ safe_VkFramebufferAttachmentImageInfoKHR::safe_VkFramebufferAttachmentImageInfoK
 }
 
 safe_VkFramebufferAttachmentImageInfoKHR::safe_VkFramebufferAttachmentImageInfoKHR() :
+    pNext(nullptr),
     pViewFormats(nullptr)
 {}
 
 safe_VkFramebufferAttachmentImageInfoKHR::safe_VkFramebufferAttachmentImageInfoKHR(const safe_VkFramebufferAttachmentImageInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     usage = src.usage;
     width = src.width;
@@ -11721,6 +12498,7 @@ safe_VkFramebufferAttachmentImageInfoKHR::safe_VkFramebufferAttachmentImageInfoK
     layerCount = src.layerCount;
     viewFormatCount = src.viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewFormats) {
         pViewFormats = new VkFormat[src.viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)src.pViewFormats, sizeof(VkFormat)*src.viewFormatCount);
@@ -11733,9 +12511,10 @@ safe_VkFramebufferAttachmentImageInfoKHR& safe_VkFramebufferAttachmentImageInfoK
 
     if (pViewFormats)
         delete[] pViewFormats;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     usage = src.usage;
     width = src.width;
@@ -11743,6 +12522,7 @@ safe_VkFramebufferAttachmentImageInfoKHR& safe_VkFramebufferAttachmentImageInfoK
     layerCount = src.layerCount;
     viewFormatCount = src.viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewFormats) {
         pViewFormats = new VkFormat[src.viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)src.pViewFormats, sizeof(VkFormat)*src.viewFormatCount);
@@ -11755,12 +12535,13 @@ safe_VkFramebufferAttachmentImageInfoKHR::~safe_VkFramebufferAttachmentImageInfo
 {
     if (pViewFormats)
         delete[] pViewFormats;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFramebufferAttachmentImageInfoKHR::initialize(const VkFramebufferAttachmentImageInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     usage = in_struct->usage;
     width = in_struct->width;
@@ -11768,6 +12549,7 @@ void safe_VkFramebufferAttachmentImageInfoKHR::initialize(const VkFramebufferAtt
     layerCount = in_struct->layerCount;
     viewFormatCount = in_struct->viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewFormats) {
         pViewFormats = new VkFormat[in_struct->viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
@@ -11777,7 +12559,6 @@ void safe_VkFramebufferAttachmentImageInfoKHR::initialize(const VkFramebufferAtt
 void safe_VkFramebufferAttachmentImageInfoKHR::initialize(const safe_VkFramebufferAttachmentImageInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     usage = src->usage;
     width = src->width;
@@ -11785,6 +12566,7 @@ void safe_VkFramebufferAttachmentImageInfoKHR::initialize(const safe_VkFramebuff
     layerCount = src->layerCount;
     viewFormatCount = src->viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pViewFormats) {
         pViewFormats = new VkFormat[src->viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)src->pViewFormats, sizeof(VkFormat)*src->viewFormatCount);
@@ -11793,31 +12575,32 @@ void safe_VkFramebufferAttachmentImageInfoKHR::initialize(const safe_VkFramebuff
 
 safe_VkFramebufferAttachmentsCreateInfoKHR::safe_VkFramebufferAttachmentsCreateInfoKHR(const VkFramebufferAttachmentsCreateInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     attachmentImageInfoCount(in_struct->attachmentImageInfoCount),
     pAttachmentImageInfos(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) {
         pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfoKHR[attachmentImageInfoCount];
-        for (uint32_t i=0; i<attachmentImageInfoCount; ++i) {
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
             pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
         }
     }
 }
 
 safe_VkFramebufferAttachmentsCreateInfoKHR::safe_VkFramebufferAttachmentsCreateInfoKHR() :
+    pNext(nullptr),
     pAttachmentImageInfos(nullptr)
 {}
 
 safe_VkFramebufferAttachmentsCreateInfoKHR::safe_VkFramebufferAttachmentsCreateInfoKHR(const safe_VkFramebufferAttachmentsCreateInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     attachmentImageInfoCount = src.attachmentImageInfoCount;
     pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentImageInfoCount && src.pAttachmentImageInfos) {
         pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfoKHR[attachmentImageInfoCount];
-        for (uint32_t i=0; i<attachmentImageInfoCount; ++i) {
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
             pAttachmentImageInfos[i].initialize(&src.pAttachmentImageInfos[i]);
         }
     }
@@ -11829,14 +12612,16 @@ safe_VkFramebufferAttachmentsCreateInfoKHR& safe_VkFramebufferAttachmentsCreateI
 
     if (pAttachmentImageInfos)
         delete[] pAttachmentImageInfos;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     attachmentImageInfoCount = src.attachmentImageInfoCount;
     pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentImageInfoCount && src.pAttachmentImageInfos) {
         pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfoKHR[attachmentImageInfoCount];
-        for (uint32_t i=0; i<attachmentImageInfoCount; ++i) {
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
             pAttachmentImageInfos[i].initialize(&src.pAttachmentImageInfos[i]);
         }
     }
@@ -11848,17 +12633,19 @@ safe_VkFramebufferAttachmentsCreateInfoKHR::~safe_VkFramebufferAttachmentsCreate
 {
     if (pAttachmentImageInfos)
         delete[] pAttachmentImageInfos;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFramebufferAttachmentsCreateInfoKHR::initialize(const VkFramebufferAttachmentsCreateInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     attachmentImageInfoCount = in_struct->attachmentImageInfoCount;
     pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentImageInfoCount && in_struct->pAttachmentImageInfos) {
         pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfoKHR[attachmentImageInfoCount];
-        for (uint32_t i=0; i<attachmentImageInfoCount; ++i) {
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
             pAttachmentImageInfos[i].initialize(&in_struct->pAttachmentImageInfos[i]);
         }
     }
@@ -11867,12 +12654,12 @@ void safe_VkFramebufferAttachmentsCreateInfoKHR::initialize(const VkFramebufferA
 void safe_VkFramebufferAttachmentsCreateInfoKHR::initialize(const safe_VkFramebufferAttachmentsCreateInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     attachmentImageInfoCount = src->attachmentImageInfoCount;
     pAttachmentImageInfos = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (attachmentImageInfoCount && src->pAttachmentImageInfos) {
         pAttachmentImageInfos = new safe_VkFramebufferAttachmentImageInfoKHR[attachmentImageInfoCount];
-        for (uint32_t i=0; i<attachmentImageInfoCount; ++i) {
+        for (uint32_t i = 0; i < attachmentImageInfoCount; ++i) {
             pAttachmentImageInfos[i].initialize(&src->pAttachmentImageInfos[i]);
         }
     }
@@ -11880,31 +12667,32 @@ void safe_VkFramebufferAttachmentsCreateInfoKHR::initialize(const safe_VkFramebu
 
 safe_VkRenderPassAttachmentBeginInfoKHR::safe_VkRenderPassAttachmentBeginInfoKHR(const VkRenderPassAttachmentBeginInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     attachmentCount(in_struct->attachmentCount),
     pAttachments(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentCount && in_struct->pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = in_struct->pAttachments[i];
         }
     }
 }
 
 safe_VkRenderPassAttachmentBeginInfoKHR::safe_VkRenderPassAttachmentBeginInfoKHR() :
+    pNext(nullptr),
     pAttachments(nullptr)
 {}
 
 safe_VkRenderPassAttachmentBeginInfoKHR::safe_VkRenderPassAttachmentBeginInfoKHR(const safe_VkRenderPassAttachmentBeginInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentCount && src.pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = src.pAttachments[i];
         }
     }
@@ -11916,14 +12704,16 @@ safe_VkRenderPassAttachmentBeginInfoKHR& safe_VkRenderPassAttachmentBeginInfoKHR
 
     if (pAttachments)
         delete[] pAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentCount && src.pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = src.pAttachments[i];
         }
     }
@@ -11935,17 +12725,19 @@ safe_VkRenderPassAttachmentBeginInfoKHR::~safe_VkRenderPassAttachmentBeginInfoKH
 {
     if (pAttachments)
         delete[] pAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassAttachmentBeginInfoKHR::initialize(const VkRenderPassAttachmentBeginInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     attachmentCount = in_struct->attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentCount && in_struct->pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = in_struct->pAttachments[i];
         }
     }
@@ -11954,12 +12746,12 @@ void safe_VkRenderPassAttachmentBeginInfoKHR::initialize(const VkRenderPassAttac
 void safe_VkRenderPassAttachmentBeginInfoKHR::initialize(const safe_VkRenderPassAttachmentBeginInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     attachmentCount = src->attachmentCount;
     pAttachments = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (attachmentCount && src->pAttachments) {
         pAttachments = new VkImageView[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i] = src->pAttachments[i];
         }
     }
@@ -11967,7 +12759,6 @@ void safe_VkRenderPassAttachmentBeginInfoKHR::initialize(const safe_VkRenderPass
 
 safe_VkAttachmentDescription2KHR::safe_VkAttachmentDescription2KHR(const VkAttachmentDescription2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     format(in_struct->format),
     samples(in_struct->samples),
@@ -11978,15 +12769,16 @@ safe_VkAttachmentDescription2KHR::safe_VkAttachmentDescription2KHR(const VkAttac
     initialLayout(in_struct->initialLayout),
     finalLayout(in_struct->finalLayout)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAttachmentDescription2KHR::safe_VkAttachmentDescription2KHR()
+safe_VkAttachmentDescription2KHR::safe_VkAttachmentDescription2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkAttachmentDescription2KHR::safe_VkAttachmentDescription2KHR(const safe_VkAttachmentDescription2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     format = src.format;
     samples = src.samples;
@@ -11996,15 +12788,17 @@ safe_VkAttachmentDescription2KHR::safe_VkAttachmentDescription2KHR(const safe_Vk
     stencilStoreOp = src.stencilStoreOp;
     initialLayout = src.initialLayout;
     finalLayout = src.finalLayout;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAttachmentDescription2KHR& safe_VkAttachmentDescription2KHR::operator=(const safe_VkAttachmentDescription2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     format = src.format;
     samples = src.samples;
@@ -12014,18 +12808,20 @@ safe_VkAttachmentDescription2KHR& safe_VkAttachmentDescription2KHR::operator=(co
     stencilStoreOp = src.stencilStoreOp;
     initialLayout = src.initialLayout;
     finalLayout = src.finalLayout;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAttachmentDescription2KHR::~safe_VkAttachmentDescription2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAttachmentDescription2KHR::initialize(const VkAttachmentDescription2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     format = in_struct->format;
     samples = in_struct->samples;
@@ -12035,12 +12831,12 @@ void safe_VkAttachmentDescription2KHR::initialize(const VkAttachmentDescription2
     stencilStoreOp = in_struct->stencilStoreOp;
     initialLayout = in_struct->initialLayout;
     finalLayout = in_struct->finalLayout;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAttachmentDescription2KHR::initialize(const safe_VkAttachmentDescription2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     format = src->format;
     samples = src->samples;
@@ -12050,68 +12846,73 @@ void safe_VkAttachmentDescription2KHR::initialize(const safe_VkAttachmentDescrip
     stencilStoreOp = src->stencilStoreOp;
     initialLayout = src->initialLayout;
     finalLayout = src->finalLayout;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkAttachmentReference2KHR::safe_VkAttachmentReference2KHR(const VkAttachmentReference2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     attachment(in_struct->attachment),
     layout(in_struct->layout),
     aspectMask(in_struct->aspectMask)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAttachmentReference2KHR::safe_VkAttachmentReference2KHR()
+safe_VkAttachmentReference2KHR::safe_VkAttachmentReference2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkAttachmentReference2KHR::safe_VkAttachmentReference2KHR(const safe_VkAttachmentReference2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     attachment = src.attachment;
     layout = src.layout;
     aspectMask = src.aspectMask;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAttachmentReference2KHR& safe_VkAttachmentReference2KHR::operator=(const safe_VkAttachmentReference2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     attachment = src.attachment;
     layout = src.layout;
     aspectMask = src.aspectMask;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAttachmentReference2KHR::~safe_VkAttachmentReference2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAttachmentReference2KHR::initialize(const VkAttachmentReference2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     attachment = in_struct->attachment;
     layout = in_struct->layout;
     aspectMask = in_struct->aspectMask;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAttachmentReference2KHR::initialize(const safe_VkAttachmentReference2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     attachment = src->attachment;
     layout = src->layout;
     aspectMask = src->aspectMask;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSubpassDescription2KHR::safe_VkSubpassDescription2KHR(const VkSubpassDescription2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     pipelineBindPoint(in_struct->pipelineBindPoint),
     viewMask(in_struct->viewMask),
@@ -12120,31 +12921,31 @@ safe_VkSubpassDescription2KHR::safe_VkSubpassDescription2KHR(const VkSubpassDesc
     colorAttachmentCount(in_struct->colorAttachmentCount),
     pColorAttachments(nullptr),
     pResolveAttachments(nullptr),
+    pDepthStencilAttachment(nullptr),
     preserveAttachmentCount(in_struct->preserveAttachmentCount),
     pPreserveAttachments(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (inputAttachmentCount && in_struct->pInputAttachments) {
         pInputAttachments = new safe_VkAttachmentReference2KHR[inputAttachmentCount];
-        for (uint32_t i=0; i<inputAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
             pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
         }
     }
     if (colorAttachmentCount && in_struct->pColorAttachments) {
         pColorAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
         }
     }
     if (colorAttachmentCount && in_struct->pResolveAttachments) {
         pResolveAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
         }
     }
     if (in_struct->pDepthStencilAttachment)
         pDepthStencilAttachment = new safe_VkAttachmentReference2KHR(in_struct->pDepthStencilAttachment);
-    else
-        pDepthStencilAttachment = NULL;
     if (in_struct->pPreserveAttachments) {
         pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
         memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
@@ -12152,16 +12953,17 @@ safe_VkSubpassDescription2KHR::safe_VkSubpassDescription2KHR(const VkSubpassDesc
 }
 
 safe_VkSubpassDescription2KHR::safe_VkSubpassDescription2KHR() :
+    pNext(nullptr),
     pInputAttachments(nullptr),
     pColorAttachments(nullptr),
     pResolveAttachments(nullptr),
+    pDepthStencilAttachment(nullptr),
     pPreserveAttachments(nullptr)
 {}
 
 safe_VkSubpassDescription2KHR::safe_VkSubpassDescription2KHR(const safe_VkSubpassDescription2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pipelineBindPoint = src.pipelineBindPoint;
     viewMask = src.viewMask;
@@ -12170,30 +12972,30 @@ safe_VkSubpassDescription2KHR::safe_VkSubpassDescription2KHR(const safe_VkSubpas
     colorAttachmentCount = src.colorAttachmentCount;
     pColorAttachments = nullptr;
     pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
     preserveAttachmentCount = src.preserveAttachmentCount;
     pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (inputAttachmentCount && src.pInputAttachments) {
         pInputAttachments = new safe_VkAttachmentReference2KHR[inputAttachmentCount];
-        for (uint32_t i=0; i<inputAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
             pInputAttachments[i].initialize(&src.pInputAttachments[i]);
         }
     }
     if (colorAttachmentCount && src.pColorAttachments) {
         pColorAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pColorAttachments[i].initialize(&src.pColorAttachments[i]);
         }
     }
     if (colorAttachmentCount && src.pResolveAttachments) {
         pResolveAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pResolveAttachments[i].initialize(&src.pResolveAttachments[i]);
         }
     }
     if (src.pDepthStencilAttachment)
         pDepthStencilAttachment = new safe_VkAttachmentReference2KHR(*src.pDepthStencilAttachment);
-    else
-        pDepthStencilAttachment = NULL;
     if (src.pPreserveAttachments) {
         pPreserveAttachments = new uint32_t[src.preserveAttachmentCount];
         memcpy ((void *)pPreserveAttachments, (void *)src.pPreserveAttachments, sizeof(uint32_t)*src.preserveAttachmentCount);
@@ -12214,9 +13016,10 @@ safe_VkSubpassDescription2KHR& safe_VkSubpassDescription2KHR::operator=(const sa
         delete pDepthStencilAttachment;
     if (pPreserveAttachments)
         delete[] pPreserveAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pipelineBindPoint = src.pipelineBindPoint;
     viewMask = src.viewMask;
@@ -12225,30 +13028,30 @@ safe_VkSubpassDescription2KHR& safe_VkSubpassDescription2KHR::operator=(const sa
     colorAttachmentCount = src.colorAttachmentCount;
     pColorAttachments = nullptr;
     pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
     preserveAttachmentCount = src.preserveAttachmentCount;
     pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (inputAttachmentCount && src.pInputAttachments) {
         pInputAttachments = new safe_VkAttachmentReference2KHR[inputAttachmentCount];
-        for (uint32_t i=0; i<inputAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
             pInputAttachments[i].initialize(&src.pInputAttachments[i]);
         }
     }
     if (colorAttachmentCount && src.pColorAttachments) {
         pColorAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pColorAttachments[i].initialize(&src.pColorAttachments[i]);
         }
     }
     if (colorAttachmentCount && src.pResolveAttachments) {
         pResolveAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pResolveAttachments[i].initialize(&src.pResolveAttachments[i]);
         }
     }
     if (src.pDepthStencilAttachment)
         pDepthStencilAttachment = new safe_VkAttachmentReference2KHR(*src.pDepthStencilAttachment);
-    else
-        pDepthStencilAttachment = NULL;
     if (src.pPreserveAttachments) {
         pPreserveAttachments = new uint32_t[src.preserveAttachmentCount];
         memcpy ((void *)pPreserveAttachments, (void *)src.pPreserveAttachments, sizeof(uint32_t)*src.preserveAttachmentCount);
@@ -12269,12 +13072,13 @@ safe_VkSubpassDescription2KHR::~safe_VkSubpassDescription2KHR()
         delete pDepthStencilAttachment;
     if (pPreserveAttachments)
         delete[] pPreserveAttachments;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSubpassDescription2KHR::initialize(const VkSubpassDescription2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     pipelineBindPoint = in_struct->pipelineBindPoint;
     viewMask = in_struct->viewMask;
@@ -12283,30 +13087,30 @@ void safe_VkSubpassDescription2KHR::initialize(const VkSubpassDescription2KHR* i
     colorAttachmentCount = in_struct->colorAttachmentCount;
     pColorAttachments = nullptr;
     pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
     preserveAttachmentCount = in_struct->preserveAttachmentCount;
     pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (inputAttachmentCount && in_struct->pInputAttachments) {
         pInputAttachments = new safe_VkAttachmentReference2KHR[inputAttachmentCount];
-        for (uint32_t i=0; i<inputAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
             pInputAttachments[i].initialize(&in_struct->pInputAttachments[i]);
         }
     }
     if (colorAttachmentCount && in_struct->pColorAttachments) {
         pColorAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pColorAttachments[i].initialize(&in_struct->pColorAttachments[i]);
         }
     }
     if (colorAttachmentCount && in_struct->pResolveAttachments) {
         pResolveAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pResolveAttachments[i].initialize(&in_struct->pResolveAttachments[i]);
         }
     }
     if (in_struct->pDepthStencilAttachment)
         pDepthStencilAttachment = new safe_VkAttachmentReference2KHR(in_struct->pDepthStencilAttachment);
-    else
-        pDepthStencilAttachment = NULL;
     if (in_struct->pPreserveAttachments) {
         pPreserveAttachments = new uint32_t[in_struct->preserveAttachmentCount];
         memcpy ((void *)pPreserveAttachments, (void *)in_struct->pPreserveAttachments, sizeof(uint32_t)*in_struct->preserveAttachmentCount);
@@ -12316,7 +13120,6 @@ void safe_VkSubpassDescription2KHR::initialize(const VkSubpassDescription2KHR* i
 void safe_VkSubpassDescription2KHR::initialize(const safe_VkSubpassDescription2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     pipelineBindPoint = src->pipelineBindPoint;
     viewMask = src->viewMask;
@@ -12325,30 +13128,30 @@ void safe_VkSubpassDescription2KHR::initialize(const safe_VkSubpassDescription2K
     colorAttachmentCount = src->colorAttachmentCount;
     pColorAttachments = nullptr;
     pResolveAttachments = nullptr;
+    pDepthStencilAttachment = nullptr;
     preserveAttachmentCount = src->preserveAttachmentCount;
     pPreserveAttachments = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (inputAttachmentCount && src->pInputAttachments) {
         pInputAttachments = new safe_VkAttachmentReference2KHR[inputAttachmentCount];
-        for (uint32_t i=0; i<inputAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < inputAttachmentCount; ++i) {
             pInputAttachments[i].initialize(&src->pInputAttachments[i]);
         }
     }
     if (colorAttachmentCount && src->pColorAttachments) {
         pColorAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pColorAttachments[i].initialize(&src->pColorAttachments[i]);
         }
     }
     if (colorAttachmentCount && src->pResolveAttachments) {
         pResolveAttachments = new safe_VkAttachmentReference2KHR[colorAttachmentCount];
-        for (uint32_t i=0; i<colorAttachmentCount; ++i) {
+        for (uint32_t i = 0; i < colorAttachmentCount; ++i) {
             pResolveAttachments[i].initialize(&src->pResolveAttachments[i]);
         }
     }
     if (src->pDepthStencilAttachment)
         pDepthStencilAttachment = new safe_VkAttachmentReference2KHR(*src->pDepthStencilAttachment);
-    else
-        pDepthStencilAttachment = NULL;
     if (src->pPreserveAttachments) {
         pPreserveAttachments = new uint32_t[src->preserveAttachmentCount];
         memcpy ((void *)pPreserveAttachments, (void *)src->pPreserveAttachments, sizeof(uint32_t)*src->preserveAttachmentCount);
@@ -12357,7 +13160,6 @@ void safe_VkSubpassDescription2KHR::initialize(const safe_VkSubpassDescription2K
 
 safe_VkSubpassDependency2KHR::safe_VkSubpassDependency2KHR(const VkSubpassDependency2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     srcSubpass(in_struct->srcSubpass),
     dstSubpass(in_struct->dstSubpass),
     srcStageMask(in_struct->srcStageMask),
@@ -12367,15 +13169,16 @@ safe_VkSubpassDependency2KHR::safe_VkSubpassDependency2KHR(const VkSubpassDepend
     dependencyFlags(in_struct->dependencyFlags),
     viewOffset(in_struct->viewOffset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSubpassDependency2KHR::safe_VkSubpassDependency2KHR()
+safe_VkSubpassDependency2KHR::safe_VkSubpassDependency2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSubpassDependency2KHR::safe_VkSubpassDependency2KHR(const safe_VkSubpassDependency2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     srcSubpass = src.srcSubpass;
     dstSubpass = src.dstSubpass;
     srcStageMask = src.srcStageMask;
@@ -12384,15 +13187,17 @@ safe_VkSubpassDependency2KHR::safe_VkSubpassDependency2KHR(const safe_VkSubpassD
     dstAccessMask = src.dstAccessMask;
     dependencyFlags = src.dependencyFlags;
     viewOffset = src.viewOffset;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSubpassDependency2KHR& safe_VkSubpassDependency2KHR::operator=(const safe_VkSubpassDependency2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     srcSubpass = src.srcSubpass;
     dstSubpass = src.dstSubpass;
     srcStageMask = src.srcStageMask;
@@ -12401,18 +13206,20 @@ safe_VkSubpassDependency2KHR& safe_VkSubpassDependency2KHR::operator=(const safe
     dstAccessMask = src.dstAccessMask;
     dependencyFlags = src.dependencyFlags;
     viewOffset = src.viewOffset;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSubpassDependency2KHR::~safe_VkSubpassDependency2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSubpassDependency2KHR::initialize(const VkSubpassDependency2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     srcSubpass = in_struct->srcSubpass;
     dstSubpass = in_struct->dstSubpass;
     srcStageMask = in_struct->srcStageMask;
@@ -12421,12 +13228,12 @@ void safe_VkSubpassDependency2KHR::initialize(const VkSubpassDependency2KHR* in_
     dstAccessMask = in_struct->dstAccessMask;
     dependencyFlags = in_struct->dependencyFlags;
     viewOffset = in_struct->viewOffset;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSubpassDependency2KHR::initialize(const safe_VkSubpassDependency2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     srcSubpass = src->srcSubpass;
     dstSubpass = src->dstSubpass;
     srcStageMask = src->srcStageMask;
@@ -12435,11 +13242,11 @@ void safe_VkSubpassDependency2KHR::initialize(const safe_VkSubpassDependency2KHR
     dstAccessMask = src->dstAccessMask;
     dependencyFlags = src->dependencyFlags;
     viewOffset = src->viewOffset;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkRenderPassCreateInfo2KHR::safe_VkRenderPassCreateInfo2KHR(const VkRenderPassCreateInfo2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     attachmentCount(in_struct->attachmentCount),
     pAttachments(nullptr),
@@ -12450,21 +13257,22 @@ safe_VkRenderPassCreateInfo2KHR::safe_VkRenderPassCreateInfo2KHR(const VkRenderP
     correlatedViewMaskCount(in_struct->correlatedViewMaskCount),
     pCorrelatedViewMasks(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentCount && in_struct->pAttachments) {
         pAttachments = new safe_VkAttachmentDescription2KHR[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i].initialize(&in_struct->pAttachments[i]);
         }
     }
     if (subpassCount && in_struct->pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription2KHR[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
         }
     }
     if (dependencyCount && in_struct->pDependencies) {
         pDependencies = new safe_VkSubpassDependency2KHR[dependencyCount];
-        for (uint32_t i=0; i<dependencyCount; ++i) {
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
             pDependencies[i].initialize(&in_struct->pDependencies[i]);
         }
     }
@@ -12475,6 +13283,7 @@ safe_VkRenderPassCreateInfo2KHR::safe_VkRenderPassCreateInfo2KHR(const VkRenderP
 }
 
 safe_VkRenderPassCreateInfo2KHR::safe_VkRenderPassCreateInfo2KHR() :
+    pNext(nullptr),
     pAttachments(nullptr),
     pSubpasses(nullptr),
     pDependencies(nullptr),
@@ -12484,7 +13293,6 @@ safe_VkRenderPassCreateInfo2KHR::safe_VkRenderPassCreateInfo2KHR() :
 safe_VkRenderPassCreateInfo2KHR::safe_VkRenderPassCreateInfo2KHR(const safe_VkRenderPassCreateInfo2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
@@ -12494,21 +13302,22 @@ safe_VkRenderPassCreateInfo2KHR::safe_VkRenderPassCreateInfo2KHR(const safe_VkRe
     pDependencies = nullptr;
     correlatedViewMaskCount = src.correlatedViewMaskCount;
     pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentCount && src.pAttachments) {
         pAttachments = new safe_VkAttachmentDescription2KHR[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i].initialize(&src.pAttachments[i]);
         }
     }
     if (subpassCount && src.pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription2KHR[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&src.pSubpasses[i]);
         }
     }
     if (dependencyCount && src.pDependencies) {
         pDependencies = new safe_VkSubpassDependency2KHR[dependencyCount];
-        for (uint32_t i=0; i<dependencyCount; ++i) {
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
             pDependencies[i].initialize(&src.pDependencies[i]);
         }
     }
@@ -12530,9 +13339,10 @@ safe_VkRenderPassCreateInfo2KHR& safe_VkRenderPassCreateInfo2KHR::operator=(cons
         delete[] pDependencies;
     if (pCorrelatedViewMasks)
         delete[] pCorrelatedViewMasks;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     attachmentCount = src.attachmentCount;
     pAttachments = nullptr;
@@ -12542,21 +13352,22 @@ safe_VkRenderPassCreateInfo2KHR& safe_VkRenderPassCreateInfo2KHR::operator=(cons
     pDependencies = nullptr;
     correlatedViewMaskCount = src.correlatedViewMaskCount;
     pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (attachmentCount && src.pAttachments) {
         pAttachments = new safe_VkAttachmentDescription2KHR[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i].initialize(&src.pAttachments[i]);
         }
     }
     if (subpassCount && src.pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription2KHR[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&src.pSubpasses[i]);
         }
     }
     if (dependencyCount && src.pDependencies) {
         pDependencies = new safe_VkSubpassDependency2KHR[dependencyCount];
-        for (uint32_t i=0; i<dependencyCount; ++i) {
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
             pDependencies[i].initialize(&src.pDependencies[i]);
         }
     }
@@ -12578,12 +13389,13 @@ safe_VkRenderPassCreateInfo2KHR::~safe_VkRenderPassCreateInfo2KHR()
         delete[] pDependencies;
     if (pCorrelatedViewMasks)
         delete[] pCorrelatedViewMasks;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassCreateInfo2KHR::initialize(const VkRenderPassCreateInfo2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     attachmentCount = in_struct->attachmentCount;
     pAttachments = nullptr;
@@ -12593,21 +13405,22 @@ void safe_VkRenderPassCreateInfo2KHR::initialize(const VkRenderPassCreateInfo2KH
     pDependencies = nullptr;
     correlatedViewMaskCount = in_struct->correlatedViewMaskCount;
     pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (attachmentCount && in_struct->pAttachments) {
         pAttachments = new safe_VkAttachmentDescription2KHR[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i].initialize(&in_struct->pAttachments[i]);
         }
     }
     if (subpassCount && in_struct->pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription2KHR[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&in_struct->pSubpasses[i]);
         }
     }
     if (dependencyCount && in_struct->pDependencies) {
         pDependencies = new safe_VkSubpassDependency2KHR[dependencyCount];
-        for (uint32_t i=0; i<dependencyCount; ++i) {
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
             pDependencies[i].initialize(&in_struct->pDependencies[i]);
         }
     }
@@ -12620,7 +13433,6 @@ void safe_VkRenderPassCreateInfo2KHR::initialize(const VkRenderPassCreateInfo2KH
 void safe_VkRenderPassCreateInfo2KHR::initialize(const safe_VkRenderPassCreateInfo2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     attachmentCount = src->attachmentCount;
     pAttachments = nullptr;
@@ -12630,21 +13442,22 @@ void safe_VkRenderPassCreateInfo2KHR::initialize(const safe_VkRenderPassCreateIn
     pDependencies = nullptr;
     correlatedViewMaskCount = src->correlatedViewMaskCount;
     pCorrelatedViewMasks = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (attachmentCount && src->pAttachments) {
         pAttachments = new safe_VkAttachmentDescription2KHR[attachmentCount];
-        for (uint32_t i=0; i<attachmentCount; ++i) {
+        for (uint32_t i = 0; i < attachmentCount; ++i) {
             pAttachments[i].initialize(&src->pAttachments[i]);
         }
     }
     if (subpassCount && src->pSubpasses) {
         pSubpasses = new safe_VkSubpassDescription2KHR[subpassCount];
-        for (uint32_t i=0; i<subpassCount; ++i) {
+        for (uint32_t i = 0; i < subpassCount; ++i) {
             pSubpasses[i].initialize(&src->pSubpasses[i]);
         }
     }
     if (dependencyCount && src->pDependencies) {
         pDependencies = new safe_VkSubpassDependency2KHR[dependencyCount];
-        for (uint32_t i=0; i<dependencyCount; ++i) {
+        for (uint32_t i = 0; i < dependencyCount; ++i) {
             pDependencies[i].initialize(&src->pDependencies[i]);
         }
     }
@@ -12656,207 +13469,227 @@ void safe_VkRenderPassCreateInfo2KHR::initialize(const safe_VkRenderPassCreateIn
 
 safe_VkSubpassBeginInfoKHR::safe_VkSubpassBeginInfoKHR(const VkSubpassBeginInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     contents(in_struct->contents)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSubpassBeginInfoKHR::safe_VkSubpassBeginInfoKHR()
+safe_VkSubpassBeginInfoKHR::safe_VkSubpassBeginInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSubpassBeginInfoKHR::safe_VkSubpassBeginInfoKHR(const safe_VkSubpassBeginInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     contents = src.contents;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSubpassBeginInfoKHR& safe_VkSubpassBeginInfoKHR::operator=(const safe_VkSubpassBeginInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     contents = src.contents;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSubpassBeginInfoKHR::~safe_VkSubpassBeginInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSubpassBeginInfoKHR::initialize(const VkSubpassBeginInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     contents = in_struct->contents;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSubpassBeginInfoKHR::initialize(const safe_VkSubpassBeginInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     contents = src->contents;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSubpassEndInfoKHR::safe_VkSubpassEndInfoKHR(const VkSubpassEndInfoKHR* in_struct) :
-    sType(in_struct->sType),
-    pNext(in_struct->pNext)
+    sType(in_struct->sType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSubpassEndInfoKHR::safe_VkSubpassEndInfoKHR()
+safe_VkSubpassEndInfoKHR::safe_VkSubpassEndInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSubpassEndInfoKHR::safe_VkSubpassEndInfoKHR(const safe_VkSubpassEndInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSubpassEndInfoKHR& safe_VkSubpassEndInfoKHR::operator=(const safe_VkSubpassEndInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSubpassEndInfoKHR::~safe_VkSubpassEndInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSubpassEndInfoKHR::initialize(const VkSubpassEndInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSubpassEndInfoKHR::initialize(const safe_VkSubpassEndInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     sharedPresentSupportedUsageFlags(in_struct->sharedPresentSupportedUsageFlags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR()
+safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSharedPresentSurfaceCapabilitiesKHR::safe_VkSharedPresentSurfaceCapabilitiesKHR(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     sharedPresentSupportedUsageFlags = src.sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSharedPresentSurfaceCapabilitiesKHR& safe_VkSharedPresentSurfaceCapabilitiesKHR::operator=(const safe_VkSharedPresentSurfaceCapabilitiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     sharedPresentSupportedUsageFlags = src.sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSharedPresentSurfaceCapabilitiesKHR::~safe_VkSharedPresentSurfaceCapabilitiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const VkSharedPresentSurfaceCapabilitiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     sharedPresentSupportedUsageFlags = in_struct->sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSharedPresentSurfaceCapabilitiesKHR::initialize(const safe_VkSharedPresentSurfaceCapabilitiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     sharedPresentSupportedUsageFlags = src->sharedPresentSupportedUsageFlags;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const VkImportFenceWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fence(in_struct->fence),
     flags(in_struct->flags),
     handleType(in_struct->handleType),
     handle(in_struct->handle),
     name(in_struct->name)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR()
+safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkImportFenceWin32HandleInfoKHR::safe_VkImportFenceWin32HandleInfoKHR(const safe_VkImportFenceWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     flags = src.flags;
     handleType = src.handleType;
     handle = src.handle;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportFenceWin32HandleInfoKHR& safe_VkImportFenceWin32HandleInfoKHR::operator=(const safe_VkImportFenceWin32HandleInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     flags = src.flags;
     handleType = src.handleType;
     handle = src.handle;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportFenceWin32HandleInfoKHR::~safe_VkImportFenceWin32HandleInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportFenceWin32HandleInfoKHR::initialize(const VkImportFenceWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fence = in_struct->fence;
     flags = in_struct->flags;
     handleType = in_struct->handleType;
     handle = in_struct->handle;
     name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fence = src->fence;
     flags = src->flags;
     handleType = src->handleType;
     handle = src->handle;
     name = src->name;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -12865,27 +13698,28 @@ void safe_VkImportFenceWin32HandleInfoKHR::initialize(const safe_VkImportFenceWi
 
 safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const VkExportFenceWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pAttributes(nullptr),
     dwAccess(in_struct->dwAccess),
     name(in_struct->name)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
 }
 
 safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR() :
+    pNext(nullptr),
     pAttributes(nullptr)
 {}
 
 safe_VkExportFenceWin32HandleInfoKHR::safe_VkExportFenceWin32HandleInfoKHR(const safe_VkExportFenceWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -12897,12 +13731,14 @@ safe_VkExportFenceWin32HandleInfoKHR& safe_VkExportFenceWin32HandleInfoKHR::oper
 
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
     name = src.name;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -12914,15 +13750,17 @@ safe_VkExportFenceWin32HandleInfoKHR::~safe_VkExportFenceWin32HandleInfoKHR()
 {
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pAttributes = nullptr;
     dwAccess = in_struct->dwAccess;
     name = in_struct->name;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
@@ -12931,10 +13769,10 @@ void safe_VkExportFenceWin32HandleInfoKHR::initialize(const VkExportFenceWin32Ha
 void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pAttributes = nullptr;
     dwAccess = src->dwAccess;
     name = src->name;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
     }
@@ -12946,559 +13784,614 @@ void safe_VkExportFenceWin32HandleInfoKHR::initialize(const safe_VkExportFenceWi
 
 safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const VkFenceGetWin32HandleInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fence(in_struct->fence),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR()
+safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkFenceGetWin32HandleInfoKHR::safe_VkFenceGetWin32HandleInfoKHR(const safe_VkFenceGetWin32HandleInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkFenceGetWin32HandleInfoKHR& safe_VkFenceGetWin32HandleInfoKHR::operator=(const safe_VkFenceGetWin32HandleInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkFenceGetWin32HandleInfoKHR::~safe_VkFenceGetWin32HandleInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFenceGetWin32HandleInfoKHR::initialize(const VkFenceGetWin32HandleInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fence = in_struct->fence;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkFenceGetWin32HandleInfoKHR::initialize(const safe_VkFenceGetWin32HandleInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fence = src->fence;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const VkImportFenceFdInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fence(in_struct->fence),
     flags(in_struct->flags),
     handleType(in_struct->handleType),
     fd(in_struct->fd)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR()
+safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkImportFenceFdInfoKHR::safe_VkImportFenceFdInfoKHR(const safe_VkImportFenceFdInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     flags = src.flags;
     handleType = src.handleType;
     fd = src.fd;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportFenceFdInfoKHR& safe_VkImportFenceFdInfoKHR::operator=(const safe_VkImportFenceFdInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     flags = src.flags;
     handleType = src.handleType;
     fd = src.fd;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportFenceFdInfoKHR::~safe_VkImportFenceFdInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportFenceFdInfoKHR::initialize(const VkImportFenceFdInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fence = in_struct->fence;
     flags = in_struct->flags;
     handleType = in_struct->handleType;
     fd = in_struct->fd;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportFenceFdInfoKHR::initialize(const safe_VkImportFenceFdInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fence = src->fence;
     flags = src->flags;
     handleType = src->handleType;
     fd = src->fd;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const VkFenceGetFdInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fence(in_struct->fence),
     handleType(in_struct->handleType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR()
+safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkFenceGetFdInfoKHR::safe_VkFenceGetFdInfoKHR(const safe_VkFenceGetFdInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkFenceGetFdInfoKHR& safe_VkFenceGetFdInfoKHR::operator=(const safe_VkFenceGetFdInfoKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fence = src.fence;
     handleType = src.handleType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkFenceGetFdInfoKHR::~safe_VkFenceGetFdInfoKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFenceGetFdInfoKHR::initialize(const VkFenceGetFdInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fence = in_struct->fence;
     handleType = in_struct->handleType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkFenceGetFdInfoKHR::initialize(const safe_VkFenceGetFdInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fence = src->fence;
     handleType = src->handleType;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     surface(in_struct->surface)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR()
+safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceSurfaceInfo2KHR::safe_VkPhysicalDeviceSurfaceInfo2KHR(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     surface = src.surface;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceSurfaceInfo2KHR& safe_VkPhysicalDeviceSurfaceInfo2KHR::operator=(const safe_VkPhysicalDeviceSurfaceInfo2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     surface = src.surface;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceSurfaceInfo2KHR::~safe_VkPhysicalDeviceSurfaceInfo2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const VkPhysicalDeviceSurfaceInfo2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     surface = in_struct->surface;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceSurfaceInfo2KHR::initialize(const safe_VkPhysicalDeviceSurfaceInfo2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     surface = src->surface;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const VkSurfaceCapabilities2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     surfaceCapabilities(in_struct->surfaceCapabilities)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR()
+safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSurfaceCapabilities2KHR::safe_VkSurfaceCapabilities2KHR(const safe_VkSurfaceCapabilities2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     surfaceCapabilities = src.surfaceCapabilities;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSurfaceCapabilities2KHR& safe_VkSurfaceCapabilities2KHR::operator=(const safe_VkSurfaceCapabilities2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     surfaceCapabilities = src.surfaceCapabilities;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSurfaceCapabilities2KHR::~safe_VkSurfaceCapabilities2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSurfaceCapabilities2KHR::initialize(const VkSurfaceCapabilities2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     surfaceCapabilities = in_struct->surfaceCapabilities;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSurfaceCapabilities2KHR::initialize(const safe_VkSurfaceCapabilities2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     surfaceCapabilities = src->surfaceCapabilities;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const VkSurfaceFormat2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     surfaceFormat(in_struct->surfaceFormat)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR()
+safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSurfaceFormat2KHR::safe_VkSurfaceFormat2KHR(const safe_VkSurfaceFormat2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     surfaceFormat = src.surfaceFormat;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSurfaceFormat2KHR& safe_VkSurfaceFormat2KHR::operator=(const safe_VkSurfaceFormat2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     surfaceFormat = src.surfaceFormat;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSurfaceFormat2KHR::~safe_VkSurfaceFormat2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSurfaceFormat2KHR::initialize(const VkSurfaceFormat2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     surfaceFormat = in_struct->surfaceFormat;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSurfaceFormat2KHR::initialize(const safe_VkSurfaceFormat2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     surfaceFormat = src->surfaceFormat;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const VkDisplayProperties2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     displayProperties(&in_struct->displayProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR()
+safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayProperties2KHR::safe_VkDisplayProperties2KHR(const safe_VkDisplayProperties2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     displayProperties.initialize(&src.displayProperties);
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayProperties2KHR& safe_VkDisplayProperties2KHR::operator=(const safe_VkDisplayProperties2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     displayProperties.initialize(&src.displayProperties);
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayProperties2KHR::~safe_VkDisplayProperties2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayProperties2KHR::initialize(const VkDisplayProperties2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     displayProperties.initialize(&in_struct->displayProperties);
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayProperties2KHR::initialize(const safe_VkDisplayProperties2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     displayProperties.initialize(&src->displayProperties);
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const VkDisplayPlaneProperties2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     displayPlaneProperties(in_struct->displayPlaneProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR()
+safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayPlaneProperties2KHR::safe_VkDisplayPlaneProperties2KHR(const safe_VkDisplayPlaneProperties2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     displayPlaneProperties = src.displayPlaneProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayPlaneProperties2KHR& safe_VkDisplayPlaneProperties2KHR::operator=(const safe_VkDisplayPlaneProperties2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     displayPlaneProperties = src.displayPlaneProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayPlaneProperties2KHR::~safe_VkDisplayPlaneProperties2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayPlaneProperties2KHR::initialize(const VkDisplayPlaneProperties2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     displayPlaneProperties = in_struct->displayPlaneProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayPlaneProperties2KHR::initialize(const safe_VkDisplayPlaneProperties2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     displayPlaneProperties = src->displayPlaneProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const VkDisplayModeProperties2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     displayModeProperties(in_struct->displayModeProperties)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR()
+safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayModeProperties2KHR::safe_VkDisplayModeProperties2KHR(const safe_VkDisplayModeProperties2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     displayModeProperties = src.displayModeProperties;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayModeProperties2KHR& safe_VkDisplayModeProperties2KHR::operator=(const safe_VkDisplayModeProperties2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     displayModeProperties = src.displayModeProperties;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayModeProperties2KHR::~safe_VkDisplayModeProperties2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayModeProperties2KHR::initialize(const VkDisplayModeProperties2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     displayModeProperties = in_struct->displayModeProperties;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayModeProperties2KHR::initialize(const safe_VkDisplayModeProperties2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     displayModeProperties = src->displayModeProperties;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const VkDisplayPlaneInfo2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     mode(in_struct->mode),
     planeIndex(in_struct->planeIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR()
+safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayPlaneInfo2KHR::safe_VkDisplayPlaneInfo2KHR(const safe_VkDisplayPlaneInfo2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     mode = src.mode;
     planeIndex = src.planeIndex;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayPlaneInfo2KHR& safe_VkDisplayPlaneInfo2KHR::operator=(const safe_VkDisplayPlaneInfo2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     mode = src.mode;
     planeIndex = src.planeIndex;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayPlaneInfo2KHR::~safe_VkDisplayPlaneInfo2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayPlaneInfo2KHR::initialize(const VkDisplayPlaneInfo2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     mode = in_struct->mode;
     planeIndex = in_struct->planeIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayPlaneInfo2KHR::initialize(const safe_VkDisplayPlaneInfo2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     mode = src->mode;
     planeIndex = src->planeIndex;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const VkDisplayPlaneCapabilities2KHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     capabilities(in_struct->capabilities)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR()
+safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayPlaneCapabilities2KHR::safe_VkDisplayPlaneCapabilities2KHR(const safe_VkDisplayPlaneCapabilities2KHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     capabilities = src.capabilities;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayPlaneCapabilities2KHR& safe_VkDisplayPlaneCapabilities2KHR::operator=(const safe_VkDisplayPlaneCapabilities2KHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     capabilities = src.capabilities;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayPlaneCapabilities2KHR::~safe_VkDisplayPlaneCapabilities2KHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayPlaneCapabilities2KHR::initialize(const VkDisplayPlaneCapabilities2KHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     capabilities = in_struct->capabilities;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayPlaneCapabilities2KHR::initialize(const safe_VkDisplayPlaneCapabilities2KHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     capabilities = src->capabilities;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageFormatListCreateInfoKHR::safe_VkImageFormatListCreateInfoKHR(const VkImageFormatListCreateInfoKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     viewFormatCount(in_struct->viewFormatCount),
     pViewFormats(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewFormats) {
         pViewFormats = new VkFormat[in_struct->viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
@@ -13506,15 +14399,16 @@ safe_VkImageFormatListCreateInfoKHR::safe_VkImageFormatListCreateInfoKHR(const V
 }
 
 safe_VkImageFormatListCreateInfoKHR::safe_VkImageFormatListCreateInfoKHR() :
+    pNext(nullptr),
     pViewFormats(nullptr)
 {}
 
 safe_VkImageFormatListCreateInfoKHR::safe_VkImageFormatListCreateInfoKHR(const safe_VkImageFormatListCreateInfoKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     viewFormatCount = src.viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewFormats) {
         pViewFormats = new VkFormat[src.viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)src.pViewFormats, sizeof(VkFormat)*src.viewFormatCount);
@@ -13527,11 +14421,13 @@ safe_VkImageFormatListCreateInfoKHR& safe_VkImageFormatListCreateInfoKHR::operat
 
     if (pViewFormats)
         delete[] pViewFormats;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     viewFormatCount = src.viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewFormats) {
         pViewFormats = new VkFormat[src.viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)src.pViewFormats, sizeof(VkFormat)*src.viewFormatCount);
@@ -13544,14 +14440,16 @@ safe_VkImageFormatListCreateInfoKHR::~safe_VkImageFormatListCreateInfoKHR()
 {
     if (pViewFormats)
         delete[] pViewFormats;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageFormatListCreateInfoKHR::initialize(const VkImageFormatListCreateInfoKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     viewFormatCount = in_struct->viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewFormats) {
         pViewFormats = new VkFormat[in_struct->viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)in_struct->pViewFormats, sizeof(VkFormat)*in_struct->viewFormatCount);
@@ -13561,9 +14459,9 @@ void safe_VkImageFormatListCreateInfoKHR::initialize(const VkImageFormatListCrea
 void safe_VkImageFormatListCreateInfoKHR::initialize(const safe_VkImageFormatListCreateInfoKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     viewFormatCount = src->viewFormatCount;
     pViewFormats = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pViewFormats) {
         pViewFormats = new VkFormat[src->viewFormatCount];
         memcpy ((void *)pViewFormats, (void *)src->pViewFormats, sizeof(VkFormat)*src->viewFormatCount);
@@ -13572,140 +14470,151 @@ void safe_VkImageFormatListCreateInfoKHR::initialize(const safe_VkImageFormatLis
 
 safe_VkPhysicalDevice8BitStorageFeaturesKHR::safe_VkPhysicalDevice8BitStorageFeaturesKHR(const VkPhysicalDevice8BitStorageFeaturesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     storageBuffer8BitAccess(in_struct->storageBuffer8BitAccess),
     uniformAndStorageBuffer8BitAccess(in_struct->uniformAndStorageBuffer8BitAccess),
     storagePushConstant8(in_struct->storagePushConstant8)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDevice8BitStorageFeaturesKHR::safe_VkPhysicalDevice8BitStorageFeaturesKHR()
+safe_VkPhysicalDevice8BitStorageFeaturesKHR::safe_VkPhysicalDevice8BitStorageFeaturesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDevice8BitStorageFeaturesKHR::safe_VkPhysicalDevice8BitStorageFeaturesKHR(const safe_VkPhysicalDevice8BitStorageFeaturesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     storageBuffer8BitAccess = src.storageBuffer8BitAccess;
     uniformAndStorageBuffer8BitAccess = src.uniformAndStorageBuffer8BitAccess;
     storagePushConstant8 = src.storagePushConstant8;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDevice8BitStorageFeaturesKHR& safe_VkPhysicalDevice8BitStorageFeaturesKHR::operator=(const safe_VkPhysicalDevice8BitStorageFeaturesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     storageBuffer8BitAccess = src.storageBuffer8BitAccess;
     uniformAndStorageBuffer8BitAccess = src.uniformAndStorageBuffer8BitAccess;
     storagePushConstant8 = src.storagePushConstant8;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDevice8BitStorageFeaturesKHR::~safe_VkPhysicalDevice8BitStorageFeaturesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDevice8BitStorageFeaturesKHR::initialize(const VkPhysicalDevice8BitStorageFeaturesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     storageBuffer8BitAccess = in_struct->storageBuffer8BitAccess;
     uniformAndStorageBuffer8BitAccess = in_struct->uniformAndStorageBuffer8BitAccess;
     storagePushConstant8 = in_struct->storagePushConstant8;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDevice8BitStorageFeaturesKHR::initialize(const safe_VkPhysicalDevice8BitStorageFeaturesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     storageBuffer8BitAccess = src->storageBuffer8BitAccess;
     uniformAndStorageBuffer8BitAccess = src->uniformAndStorageBuffer8BitAccess;
     storagePushConstant8 = src->storagePushConstant8;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderBufferInt64Atomics(in_struct->shaderBufferInt64Atomics),
     shaderSharedInt64Atomics(in_struct->shaderSharedInt64Atomics)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR()
+safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderBufferInt64Atomics = src.shaderBufferInt64Atomics;
     shaderSharedInt64Atomics = src.shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::operator=(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderBufferInt64Atomics = src.shaderBufferInt64Atomics;
     shaderSharedInt64Atomics = src.shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::~safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::initialize(const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderBufferInt64Atomics = in_struct->shaderBufferInt64Atomics;
     shaderSharedInt64Atomics = in_struct->shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR::initialize(const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderBufferInt64Atomics = src->shaderBufferInt64Atomics;
     shaderSharedInt64Atomics = src->shaderSharedInt64Atomics;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceDriverPropertiesKHR::safe_VkPhysicalDeviceDriverPropertiesKHR(const VkPhysicalDeviceDriverPropertiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     driverID(in_struct->driverID),
     conformanceVersion(in_struct->conformanceVersion)
 {
-    for (uint32_t i=0; i<VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
         driverName[i] = in_struct->driverName[i];
     }
-    for (uint32_t i=0; i<VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
         driverInfo[i] = in_struct->driverInfo[i];
     }
 }
 
-safe_VkPhysicalDeviceDriverPropertiesKHR::safe_VkPhysicalDeviceDriverPropertiesKHR()
+safe_VkPhysicalDeviceDriverPropertiesKHR::safe_VkPhysicalDeviceDriverPropertiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceDriverPropertiesKHR::safe_VkPhysicalDeviceDriverPropertiesKHR(const safe_VkPhysicalDeviceDriverPropertiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     driverID = src.driverID;
     conformanceVersion = src.conformanceVersion;
-    for (uint32_t i=0; i<VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
         driverName[i] = src.driverName[i];
     }
-    for (uint32_t i=0; i<VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
         driverInfo[i] = src.driverInfo[i];
     }
 }
@@ -13714,15 +14623,17 @@ safe_VkPhysicalDeviceDriverPropertiesKHR& safe_VkPhysicalDeviceDriverPropertiesK
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     driverID = src.driverID;
     conformanceVersion = src.conformanceVersion;
-    for (uint32_t i=0; i<VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
         driverName[i] = src.driverName[i];
     }
-    for (uint32_t i=0; i<VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
         driverInfo[i] = src.driverInfo[i];
     }
 
@@ -13731,18 +14642,20 @@ safe_VkPhysicalDeviceDriverPropertiesKHR& safe_VkPhysicalDeviceDriverPropertiesK
 
 safe_VkPhysicalDeviceDriverPropertiesKHR::~safe_VkPhysicalDeviceDriverPropertiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceDriverPropertiesKHR::initialize(const VkPhysicalDeviceDriverPropertiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     driverID = in_struct->driverID;
     conformanceVersion = in_struct->conformanceVersion;
-    for (uint32_t i=0; i<VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
         driverName[i] = in_struct->driverName[i];
     }
-    for (uint32_t i=0; i<VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
         driverInfo[i] = in_struct->driverInfo[i];
     }
 }
@@ -13750,22 +14663,21 @@ void safe_VkPhysicalDeviceDriverPropertiesKHR::initialize(const VkPhysicalDevice
 void safe_VkPhysicalDeviceDriverPropertiesKHR::initialize(const safe_VkPhysicalDeviceDriverPropertiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     driverID = src->driverID;
     conformanceVersion = src->conformanceVersion;
-    for (uint32_t i=0; i<VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_NAME_SIZE_KHR; ++i) {
         driverName[i] = src->driverName[i];
     }
-    for (uint32_t i=0; i<VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_DRIVER_INFO_SIZE_KHR; ++i) {
         driverInfo[i] = src->driverInfo[i];
     }
 }
 
 safe_VkPhysicalDeviceFloatControlsPropertiesKHR::safe_VkPhysicalDeviceFloatControlsPropertiesKHR(const VkPhysicalDeviceFloatControlsPropertiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
-    separateDenormSettings(in_struct->separateDenormSettings),
-    separateRoundingModeSettings(in_struct->separateRoundingModeSettings),
+    denormBehaviorIndependence(in_struct->denormBehaviorIndependence),
+    roundingModeIndependence(in_struct->roundingModeIndependence),
     shaderSignedZeroInfNanPreserveFloat16(in_struct->shaderSignedZeroInfNanPreserveFloat16),
     shaderSignedZeroInfNanPreserveFloat32(in_struct->shaderSignedZeroInfNanPreserveFloat32),
     shaderSignedZeroInfNanPreserveFloat64(in_struct->shaderSignedZeroInfNanPreserveFloat64),
@@ -13782,17 +14694,18 @@ safe_VkPhysicalDeviceFloatControlsPropertiesKHR::safe_VkPhysicalDeviceFloatContr
     shaderRoundingModeRTZFloat32(in_struct->shaderRoundingModeRTZFloat32),
     shaderRoundingModeRTZFloat64(in_struct->shaderRoundingModeRTZFloat64)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceFloatControlsPropertiesKHR::safe_VkPhysicalDeviceFloatControlsPropertiesKHR()
+safe_VkPhysicalDeviceFloatControlsPropertiesKHR::safe_VkPhysicalDeviceFloatControlsPropertiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceFloatControlsPropertiesKHR::safe_VkPhysicalDeviceFloatControlsPropertiesKHR(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
-    separateDenormSettings = src.separateDenormSettings;
-    separateRoundingModeSettings = src.separateRoundingModeSettings;
+    denormBehaviorIndependence = src.denormBehaviorIndependence;
+    roundingModeIndependence = src.roundingModeIndependence;
     shaderSignedZeroInfNanPreserveFloat16 = src.shaderSignedZeroInfNanPreserveFloat16;
     shaderSignedZeroInfNanPreserveFloat32 = src.shaderSignedZeroInfNanPreserveFloat32;
     shaderSignedZeroInfNanPreserveFloat64 = src.shaderSignedZeroInfNanPreserveFloat64;
@@ -13808,17 +14721,19 @@ safe_VkPhysicalDeviceFloatControlsPropertiesKHR::safe_VkPhysicalDeviceFloatContr
     shaderRoundingModeRTZFloat16 = src.shaderRoundingModeRTZFloat16;
     shaderRoundingModeRTZFloat32 = src.shaderRoundingModeRTZFloat32;
     shaderRoundingModeRTZFloat64 = src.shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceFloatControlsPropertiesKHR& safe_VkPhysicalDeviceFloatControlsPropertiesKHR::operator=(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
-    separateDenormSettings = src.separateDenormSettings;
-    separateRoundingModeSettings = src.separateRoundingModeSettings;
+    denormBehaviorIndependence = src.denormBehaviorIndependence;
+    roundingModeIndependence = src.roundingModeIndependence;
     shaderSignedZeroInfNanPreserveFloat16 = src.shaderSignedZeroInfNanPreserveFloat16;
     shaderSignedZeroInfNanPreserveFloat32 = src.shaderSignedZeroInfNanPreserveFloat32;
     shaderSignedZeroInfNanPreserveFloat64 = src.shaderSignedZeroInfNanPreserveFloat64;
@@ -13834,20 +14749,22 @@ safe_VkPhysicalDeviceFloatControlsPropertiesKHR& safe_VkPhysicalDeviceFloatContr
     shaderRoundingModeRTZFloat16 = src.shaderRoundingModeRTZFloat16;
     shaderRoundingModeRTZFloat32 = src.shaderRoundingModeRTZFloat32;
     shaderRoundingModeRTZFloat64 = src.shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceFloatControlsPropertiesKHR::~safe_VkPhysicalDeviceFloatControlsPropertiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceFloatControlsPropertiesKHR::initialize(const VkPhysicalDeviceFloatControlsPropertiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
-    separateDenormSettings = in_struct->separateDenormSettings;
-    separateRoundingModeSettings = in_struct->separateRoundingModeSettings;
+    denormBehaviorIndependence = in_struct->denormBehaviorIndependence;
+    roundingModeIndependence = in_struct->roundingModeIndependence;
     shaderSignedZeroInfNanPreserveFloat16 = in_struct->shaderSignedZeroInfNanPreserveFloat16;
     shaderSignedZeroInfNanPreserveFloat32 = in_struct->shaderSignedZeroInfNanPreserveFloat32;
     shaderSignedZeroInfNanPreserveFloat64 = in_struct->shaderSignedZeroInfNanPreserveFloat64;
@@ -13863,14 +14780,14 @@ void safe_VkPhysicalDeviceFloatControlsPropertiesKHR::initialize(const VkPhysica
     shaderRoundingModeRTZFloat16 = in_struct->shaderRoundingModeRTZFloat16;
     shaderRoundingModeRTZFloat32 = in_struct->shaderRoundingModeRTZFloat32;
     shaderRoundingModeRTZFloat64 = in_struct->shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceFloatControlsPropertiesKHR::initialize(const safe_VkPhysicalDeviceFloatControlsPropertiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
-    separateDenormSettings = src->separateDenormSettings;
-    separateRoundingModeSettings = src->separateRoundingModeSettings;
+    denormBehaviorIndependence = src->denormBehaviorIndependence;
+    roundingModeIndependence = src->roundingModeIndependence;
     shaderSignedZeroInfNanPreserveFloat16 = src->shaderSignedZeroInfNanPreserveFloat16;
     shaderSignedZeroInfNanPreserveFloat32 = src->shaderSignedZeroInfNanPreserveFloat32;
     shaderSignedZeroInfNanPreserveFloat64 = src->shaderSignedZeroInfNanPreserveFloat64;
@@ -13886,33 +14803,34 @@ void safe_VkPhysicalDeviceFloatControlsPropertiesKHR::initialize(const safe_VkPh
     shaderRoundingModeRTZFloat16 = src->shaderRoundingModeRTZFloat16;
     shaderRoundingModeRTZFloat32 = src->shaderRoundingModeRTZFloat32;
     shaderRoundingModeRTZFloat64 = src->shaderRoundingModeRTZFloat64;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSubpassDescriptionDepthStencilResolveKHR::safe_VkSubpassDescriptionDepthStencilResolveKHR(const VkSubpassDescriptionDepthStencilResolveKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     depthResolveMode(in_struct->depthResolveMode),
-    stencilResolveMode(in_struct->stencilResolveMode)
+    stencilResolveMode(in_struct->stencilResolveMode),
+    pDepthStencilResolveAttachment(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDepthStencilResolveAttachment)
         pDepthStencilResolveAttachment = new safe_VkAttachmentReference2KHR(in_struct->pDepthStencilResolveAttachment);
-    else
-        pDepthStencilResolveAttachment = NULL;
 }
 
-safe_VkSubpassDescriptionDepthStencilResolveKHR::safe_VkSubpassDescriptionDepthStencilResolveKHR()
+safe_VkSubpassDescriptionDepthStencilResolveKHR::safe_VkSubpassDescriptionDepthStencilResolveKHR() :
+    pNext(nullptr),
+    pDepthStencilResolveAttachment(nullptr)
 {}
 
 safe_VkSubpassDescriptionDepthStencilResolveKHR::safe_VkSubpassDescriptionDepthStencilResolveKHR(const safe_VkSubpassDescriptionDepthStencilResolveKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     depthResolveMode = src.depthResolveMode;
     stencilResolveMode = src.stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDepthStencilResolveAttachment)
         pDepthStencilResolveAttachment = new safe_VkAttachmentReference2KHR(*src.pDepthStencilResolveAttachment);
-    else
-        pDepthStencilResolveAttachment = NULL;
 }
 
 safe_VkSubpassDescriptionDepthStencilResolveKHR& safe_VkSubpassDescriptionDepthStencilResolveKHR::operator=(const safe_VkSubpassDescriptionDepthStencilResolveKHR& src)
@@ -13921,15 +14839,16 @@ safe_VkSubpassDescriptionDepthStencilResolveKHR& safe_VkSubpassDescriptionDepthS
 
     if (pDepthStencilResolveAttachment)
         delete pDepthStencilResolveAttachment;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     depthResolveMode = src.depthResolveMode;
     stencilResolveMode = src.stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDepthStencilResolveAttachment)
         pDepthStencilResolveAttachment = new safe_VkAttachmentReference2KHR(*src.pDepthStencilResolveAttachment);
-    else
-        pDepthStencilResolveAttachment = NULL;
 
     return *this;
 }
@@ -13938,492 +14857,967 @@ safe_VkSubpassDescriptionDepthStencilResolveKHR::~safe_VkSubpassDescriptionDepth
 {
     if (pDepthStencilResolveAttachment)
         delete pDepthStencilResolveAttachment;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSubpassDescriptionDepthStencilResolveKHR::initialize(const VkSubpassDescriptionDepthStencilResolveKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     depthResolveMode = in_struct->depthResolveMode;
     stencilResolveMode = in_struct->stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDepthStencilResolveAttachment)
         pDepthStencilResolveAttachment = new safe_VkAttachmentReference2KHR(in_struct->pDepthStencilResolveAttachment);
-    else
-        pDepthStencilResolveAttachment = NULL;
 }
 
 void safe_VkSubpassDescriptionDepthStencilResolveKHR::initialize(const safe_VkSubpassDescriptionDepthStencilResolveKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     depthResolveMode = src->depthResolveMode;
     stencilResolveMode = src->stencilResolveMode;
+    pDepthStencilResolveAttachment = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDepthStencilResolveAttachment)
         pDepthStencilResolveAttachment = new safe_VkAttachmentReference2KHR(*src->pDepthStencilResolveAttachment);
-    else
-        pDepthStencilResolveAttachment = NULL;
 }
 
 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(const VkPhysicalDeviceDepthStencilResolvePropertiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     supportedDepthResolveModes(in_struct->supportedDepthResolveModes),
     supportedStencilResolveModes(in_struct->supportedStencilResolveModes),
     independentResolveNone(in_struct->independentResolveNone),
     independentResolve(in_struct->independentResolve)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR()
+safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     supportedDepthResolveModes = src.supportedDepthResolveModes;
     supportedStencilResolveModes = src.supportedStencilResolveModes;
     independentResolveNone = src.independentResolveNone;
     independentResolve = src.independentResolve;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::operator=(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     supportedDepthResolveModes = src.supportedDepthResolveModes;
     supportedStencilResolveModes = src.supportedStencilResolveModes;
     independentResolveNone = src.independentResolveNone;
     independentResolve = src.independentResolve;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::~safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::initialize(const VkPhysicalDeviceDepthStencilResolvePropertiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     supportedDepthResolveModes = in_struct->supportedDepthResolveModes;
     supportedStencilResolveModes = in_struct->supportedStencilResolveModes;
     independentResolveNone = in_struct->independentResolveNone;
     independentResolve = in_struct->independentResolve;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR::initialize(const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     supportedDepthResolveModes = src->supportedDepthResolveModes;
     supportedStencilResolveModes = src->supportedStencilResolveModes;
     independentResolveNone = src->independentResolveNone;
     independentResolve = src->independentResolve;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     vulkanMemoryModel(in_struct->vulkanMemoryModel),
     vulkanMemoryModelDeviceScope(in_struct->vulkanMemoryModelDeviceScope),
     vulkanMemoryModelAvailabilityVisibilityChains(in_struct->vulkanMemoryModelAvailabilityVisibilityChains)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR()
+safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     vulkanMemoryModel = src.vulkanMemoryModel;
     vulkanMemoryModelDeviceScope = src.vulkanMemoryModelDeviceScope;
     vulkanMemoryModelAvailabilityVisibilityChains = src.vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::operator=(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     vulkanMemoryModel = src.vulkanMemoryModel;
     vulkanMemoryModelDeviceScope = src.vulkanMemoryModelDeviceScope;
     vulkanMemoryModelAvailabilityVisibilityChains = src.vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::~safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::initialize(const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     vulkanMemoryModel = in_struct->vulkanMemoryModel;
     vulkanMemoryModelDeviceScope = in_struct->vulkanMemoryModelDeviceScope;
     vulkanMemoryModelAvailabilityVisibilityChains = in_struct->vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR::initialize(const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     vulkanMemoryModel = src->vulkanMemoryModel;
     vulkanMemoryModelDeviceScope = src->vulkanMemoryModelDeviceScope;
     vulkanMemoryModelAvailabilityVisibilityChains = src->vulkanMemoryModelAvailabilityVisibilityChains;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const VkSurfaceProtectedCapabilitiesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     supportsProtected(in_struct->supportsProtected)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR()
+safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkSurfaceProtectedCapabilitiesKHR::safe_VkSurfaceProtectedCapabilitiesKHR(const safe_VkSurfaceProtectedCapabilitiesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     supportsProtected = src.supportsProtected;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSurfaceProtectedCapabilitiesKHR& safe_VkSurfaceProtectedCapabilitiesKHR::operator=(const safe_VkSurfaceProtectedCapabilitiesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     supportsProtected = src.supportsProtected;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSurfaceProtectedCapabilitiesKHR::~safe_VkSurfaceProtectedCapabilitiesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const VkSurfaceProtectedCapabilitiesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     supportsProtected = in_struct->supportsProtected;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSurfaceProtectedCapabilitiesKHR::initialize(const safe_VkSurfaceProtectedCapabilitiesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     supportsProtected = src->supportsProtected;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     uniformBufferStandardLayout(in_struct->uniformBufferStandardLayout)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR()
+safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     uniformBufferStandardLayout = src.uniformBufferStandardLayout;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::operator=(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     uniformBufferStandardLayout = src.uniformBufferStandardLayout;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::~safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::initialize(const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     uniformBufferStandardLayout = in_struct->uniformBufferStandardLayout;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR::initialize(const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     uniformBufferStandardLayout = src->uniformBufferStandardLayout;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct) :
+    sType(in_struct->sType),
+    pipelineExecutableInfo(in_struct->pipelineExecutableInfo)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src)
+{
+    sType = src.sType;
+    pipelineExecutableInfo = src.pipelineExecutableInfo;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::operator=(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    pipelineExecutableInfo = src.pipelineExecutableInfo;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct)
+{
+    sType = in_struct->sType;
+    pipelineExecutableInfo = in_struct->pipelineExecutableInfo;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR::initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* src)
+{
+    sType = src->sType;
+    pipelineExecutableInfo = src->pipelineExecutableInfo;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct) :
+    sType(in_struct->sType),
+    pipeline(in_struct->pipeline)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR() :
+    pNext(nullptr)
+{}
+
+safe_VkPipelineInfoKHR::safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& src)
+{
+    sType = src.sType;
+    pipeline = src.pipeline;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPipelineInfoKHR& safe_VkPipelineInfoKHR::operator=(const safe_VkPipelineInfoKHR& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    pipeline = src.pipeline;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineInfoKHR::~safe_VkPipelineInfoKHR()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineInfoKHR::initialize(const VkPipelineInfoKHR* in_struct)
+{
+    sType = in_struct->sType;
+    pipeline = in_struct->pipeline;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPipelineInfoKHR::initialize(const safe_VkPipelineInfoKHR* src)
+{
+    sType = src->sType;
+    pipeline = src->pipeline;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct) :
+    sType(in_struct->sType),
+    stages(in_struct->stages),
+    subgroupSize(in_struct->subgroupSize)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR() :
+    pNext(nullptr)
+{}
+
+safe_VkPipelineExecutablePropertiesKHR::safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& src)
+{
+    sType = src.sType;
+    stages = src.stages;
+    subgroupSize = src.subgroupSize;
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src.name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src.description[i];
+    }
+}
+
+safe_VkPipelineExecutablePropertiesKHR& safe_VkPipelineExecutablePropertiesKHR::operator=(const safe_VkPipelineExecutablePropertiesKHR& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    stages = src.stages;
+    subgroupSize = src.subgroupSize;
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src.name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src.description[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineExecutablePropertiesKHR::~safe_VkPipelineExecutablePropertiesKHR()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineExecutablePropertiesKHR::initialize(const VkPipelineExecutablePropertiesKHR* in_struct)
+{
+    sType = in_struct->sType;
+    stages = in_struct->stages;
+    subgroupSize = in_struct->subgroupSize;
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+void safe_VkPipelineExecutablePropertiesKHR::initialize(const safe_VkPipelineExecutablePropertiesKHR* src)
+{
+    sType = src->sType;
+    stages = src->stages;
+    subgroupSize = src->subgroupSize;
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src->description[i];
+    }
+}
+
+safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct) :
+    sType(in_struct->sType),
+    pipeline(in_struct->pipeline),
+    executableIndex(in_struct->executableIndex)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR() :
+    pNext(nullptr)
+{}
+
+safe_VkPipelineExecutableInfoKHR::safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& src)
+{
+    sType = src.sType;
+    pipeline = src.pipeline;
+    executableIndex = src.executableIndex;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPipelineExecutableInfoKHR& safe_VkPipelineExecutableInfoKHR::operator=(const safe_VkPipelineExecutableInfoKHR& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    pipeline = src.pipeline;
+    executableIndex = src.executableIndex;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineExecutableInfoKHR::~safe_VkPipelineExecutableInfoKHR()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineExecutableInfoKHR::initialize(const VkPipelineExecutableInfoKHR* in_struct)
+{
+    sType = in_struct->sType;
+    pipeline = in_struct->pipeline;
+    executableIndex = in_struct->executableIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPipelineExecutableInfoKHR::initialize(const safe_VkPipelineExecutableInfoKHR* src)
+{
+    sType = src->sType;
+    pipeline = src->pipeline;
+    executableIndex = src->executableIndex;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct) :
+    sType(in_struct->sType),
+    format(in_struct->format),
+    value(in_struct->value)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR() :
+    pNext(nullptr)
+{}
+
+safe_VkPipelineExecutableStatisticKHR::safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& src)
+{
+    sType = src.sType;
+    format = src.format;
+    value = src.value;
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src.name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src.description[i];
+    }
+}
+
+safe_VkPipelineExecutableStatisticKHR& safe_VkPipelineExecutableStatisticKHR::operator=(const safe_VkPipelineExecutableStatisticKHR& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    format = src.format;
+    value = src.value;
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src.name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src.description[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineExecutableStatisticKHR::~safe_VkPipelineExecutableStatisticKHR()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineExecutableStatisticKHR::initialize(const VkPipelineExecutableStatisticKHR* in_struct)
+{
+    sType = in_struct->sType;
+    format = in_struct->format;
+    value = in_struct->value;
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+void safe_VkPipelineExecutableStatisticKHR::initialize(const safe_VkPipelineExecutableStatisticKHR* src)
+{
+    sType = src->sType;
+    format = src->format;
+    value = src->value;
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src->description[i];
+    }
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct) :
+    sType(in_struct->sType),
+    isText(in_struct->isText),
+    dataSize(in_struct->dataSize),
+    pData(in_struct->pData)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR() :
+    pNext(nullptr),
+    pData(nullptr)
+{}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& src)
+{
+    sType = src.sType;
+    isText = src.isText;
+    dataSize = src.dataSize;
+    pData = src.pData;
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src.name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src.description[i];
+    }
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR& safe_VkPipelineExecutableInternalRepresentationKHR::operator=(const safe_VkPipelineExecutableInternalRepresentationKHR& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    isText = src.isText;
+    dataSize = src.dataSize;
+    pData = src.pData;
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src.name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src.description[i];
+    }
+
+    return *this;
+}
+
+safe_VkPipelineExecutableInternalRepresentationKHR::~safe_VkPipelineExecutableInternalRepresentationKHR()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct)
+{
+    sType = in_struct->sType;
+    isText = in_struct->isText;
+    dataSize = in_struct->dataSize;
+    pData = in_struct->pData;
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = in_struct->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = in_struct->description[i];
+    }
+}
+
+void safe_VkPipelineExecutableInternalRepresentationKHR::initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* src)
+{
+    sType = src->sType;
+    isText = src->isText;
+    dataSize = src->dataSize;
+    pData = src->pData;
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        name[i] = src->name[i];
+    }
+    for (uint32_t i = 0; i < VK_MAX_DESCRIPTION_SIZE; ++i) {
+        description[i] = src->description[i];
+    }
 }
 
 safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(const VkDebugReportCallbackCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     pfnCallback(in_struct->pfnCallback),
     pUserData(in_struct->pUserData)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT()
+safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT() :
+    pNext(nullptr),
+    pUserData(nullptr)
 {}
 
 safe_VkDebugReportCallbackCreateInfoEXT::safe_VkDebugReportCallbackCreateInfoEXT(const safe_VkDebugReportCallbackCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pfnCallback = src.pfnCallback;
     pUserData = src.pUserData;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDebugReportCallbackCreateInfoEXT& safe_VkDebugReportCallbackCreateInfoEXT::operator=(const safe_VkDebugReportCallbackCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pfnCallback = src.pfnCallback;
     pUserData = src.pUserData;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDebugReportCallbackCreateInfoEXT::~safe_VkDebugReportCallbackCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const VkDebugReportCallbackCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     pfnCallback = in_struct->pfnCallback;
     pUserData = in_struct->pUserData;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDebugReportCallbackCreateInfoEXT::initialize(const safe_VkDebugReportCallbackCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     pfnCallback = src->pfnCallback;
     pUserData = src->pUserData;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     rasterizationOrder(in_struct->rasterizationOrder)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD()
+safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineRasterizationStateRasterizationOrderAMD::safe_VkPipelineRasterizationStateRasterizationOrderAMD(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     rasterizationOrder = src.rasterizationOrder;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineRasterizationStateRasterizationOrderAMD& safe_VkPipelineRasterizationStateRasterizationOrderAMD::operator=(const safe_VkPipelineRasterizationStateRasterizationOrderAMD& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     rasterizationOrder = src.rasterizationOrder;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineRasterizationStateRasterizationOrderAMD::~safe_VkPipelineRasterizationStateRasterizationOrderAMD()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(const VkPipelineRasterizationStateRasterizationOrderAMD* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     rasterizationOrder = in_struct->rasterizationOrder;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineRasterizationStateRasterizationOrderAMD::initialize(const safe_VkPipelineRasterizationStateRasterizationOrderAMD* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     rasterizationOrder = src->rasterizationOrder;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const VkDebugMarkerObjectNameInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     objectType(in_struct->objectType),
-    object(in_struct->object),
-    pObjectName(in_struct->pObjectName)
+    object(in_struct->object)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
 }
 
-safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT()
+safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT() :
+    pNext(nullptr),
+    pObjectName(nullptr)
 {}
 
 safe_VkDebugMarkerObjectNameInfoEXT::safe_VkDebugMarkerObjectNameInfoEXT(const safe_VkDebugMarkerObjectNameInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     object = src.object;
-    pObjectName = src.pObjectName;
+    pNext = SafePnextCopy(src.pNext);
+    pObjectName = SafeStringCopy(src.pObjectName);
 }
 
 safe_VkDebugMarkerObjectNameInfoEXT& safe_VkDebugMarkerObjectNameInfoEXT::operator=(const safe_VkDebugMarkerObjectNameInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pObjectName) delete [] pObjectName;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     object = src.object;
-    pObjectName = src.pObjectName;
+    pNext = SafePnextCopy(src.pNext);
+    pObjectName = SafeStringCopy(src.pObjectName);
 
     return *this;
 }
 
 safe_VkDebugMarkerObjectNameInfoEXT::~safe_VkDebugMarkerObjectNameInfoEXT()
 {
+    if (pObjectName) delete [] pObjectName;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const VkDebugMarkerObjectNameInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     objectType = in_struct->objectType;
     object = in_struct->object;
-    pObjectName = in_struct->pObjectName;
+    pNext = SafePnextCopy(in_struct->pNext);
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
 }
 
 void safe_VkDebugMarkerObjectNameInfoEXT::initialize(const safe_VkDebugMarkerObjectNameInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     objectType = src->objectType;
     object = src->object;
-    pObjectName = src->pObjectName;
+    pNext = SafePnextCopy(src->pNext);
+    pObjectName = SafeStringCopy(src->pObjectName);
 }
 
 safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const VkDebugMarkerObjectTagInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     objectType(in_struct->objectType),
     object(in_struct->object),
     tagName(in_struct->tagName),
     tagSize(in_struct->tagSize),
     pTag(in_struct->pTag)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT()
+safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT() :
+    pNext(nullptr),
+    pTag(nullptr)
 {}
 
 safe_VkDebugMarkerObjectTagInfoEXT::safe_VkDebugMarkerObjectTagInfoEXT(const safe_VkDebugMarkerObjectTagInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     object = src.object;
     tagName = src.tagName;
     tagSize = src.tagSize;
     pTag = src.pTag;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDebugMarkerObjectTagInfoEXT& safe_VkDebugMarkerObjectTagInfoEXT::operator=(const safe_VkDebugMarkerObjectTagInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     object = src.object;
     tagName = src.tagName;
     tagSize = src.tagSize;
     pTag = src.pTag;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDebugMarkerObjectTagInfoEXT::~safe_VkDebugMarkerObjectTagInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const VkDebugMarkerObjectTagInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     objectType = in_struct->objectType;
     object = in_struct->object;
     tagName = in_struct->tagName;
     tagSize = in_struct->tagSize;
     pTag = in_struct->pTag;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDebugMarkerObjectTagInfoEXT::initialize(const safe_VkDebugMarkerObjectTagInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     objectType = src->objectType;
     object = src->object;
     tagName = src->tagName;
     tagSize = src->tagSize;
     pTag = src->pTag;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const VkDebugMarkerMarkerInfoEXT* in_struct) :
-    sType(in_struct->sType),
-    pNext(in_struct->pNext),
-    pMarkerName(in_struct->pMarkerName)
+    sType(in_struct->sType)
 {
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pMarkerName = SafeStringCopy(in_struct->pMarkerName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = in_struct->color[i];
     }
 }
 
-safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT()
+safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT() :
+    pNext(nullptr),
+    pMarkerName(nullptr)
 {}
 
 safe_VkDebugMarkerMarkerInfoEXT::safe_VkDebugMarkerMarkerInfoEXT(const safe_VkDebugMarkerMarkerInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
-    pMarkerName = src.pMarkerName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    pMarkerName = SafeStringCopy(src.pMarkerName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = src.color[i];
     }
 }
@@ -14432,11 +15826,14 @@ safe_VkDebugMarkerMarkerInfoEXT& safe_VkDebugMarkerMarkerInfoEXT::operator=(cons
 {
     if (&src == this) return *this;
 
+    if (pMarkerName) delete [] pMarkerName;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
-    pMarkerName = src.pMarkerName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    pMarkerName = SafeStringCopy(src.pMarkerName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = src.color[i];
     }
 
@@ -14445,14 +15842,17 @@ safe_VkDebugMarkerMarkerInfoEXT& safe_VkDebugMarkerMarkerInfoEXT::operator=(cons
 
 safe_VkDebugMarkerMarkerInfoEXT::~safe_VkDebugMarkerMarkerInfoEXT()
 {
+    if (pMarkerName) delete [] pMarkerName;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugMarkerMarkerInfoEXT::initialize(const VkDebugMarkerMarkerInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
-    pMarkerName = in_struct->pMarkerName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pMarkerName = SafeStringCopy(in_struct->pMarkerName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = in_struct->color[i];
     }
 }
@@ -14460,214 +15860,233 @@ void safe_VkDebugMarkerMarkerInfoEXT::initialize(const VkDebugMarkerMarkerInfoEX
 void safe_VkDebugMarkerMarkerInfoEXT::initialize(const safe_VkDebugMarkerMarkerInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
-    pMarkerName = src->pMarkerName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    pMarkerName = SafeStringCopy(src->pMarkerName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = src->color[i];
     }
 }
 
 safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(const VkDedicatedAllocationImageCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     dedicatedAllocation(in_struct->dedicatedAllocation)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV()
+safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkDedicatedAllocationImageCreateInfoNV::safe_VkDedicatedAllocationImageCreateInfoNV(const safe_VkDedicatedAllocationImageCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     dedicatedAllocation = src.dedicatedAllocation;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDedicatedAllocationImageCreateInfoNV& safe_VkDedicatedAllocationImageCreateInfoNV::operator=(const safe_VkDedicatedAllocationImageCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     dedicatedAllocation = src.dedicatedAllocation;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDedicatedAllocationImageCreateInfoNV::~safe_VkDedicatedAllocationImageCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const VkDedicatedAllocationImageCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     dedicatedAllocation = in_struct->dedicatedAllocation;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDedicatedAllocationImageCreateInfoNV::initialize(const safe_VkDedicatedAllocationImageCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     dedicatedAllocation = src->dedicatedAllocation;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(const VkDedicatedAllocationBufferCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     dedicatedAllocation(in_struct->dedicatedAllocation)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV()
+safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkDedicatedAllocationBufferCreateInfoNV::safe_VkDedicatedAllocationBufferCreateInfoNV(const safe_VkDedicatedAllocationBufferCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     dedicatedAllocation = src.dedicatedAllocation;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDedicatedAllocationBufferCreateInfoNV& safe_VkDedicatedAllocationBufferCreateInfoNV::operator=(const safe_VkDedicatedAllocationBufferCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     dedicatedAllocation = src.dedicatedAllocation;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDedicatedAllocationBufferCreateInfoNV::~safe_VkDedicatedAllocationBufferCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const VkDedicatedAllocationBufferCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     dedicatedAllocation = in_struct->dedicatedAllocation;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDedicatedAllocationBufferCreateInfoNV::initialize(const safe_VkDedicatedAllocationBufferCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     dedicatedAllocation = src->dedicatedAllocation;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     image(in_struct->image),
     buffer(in_struct->buffer)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV()
+safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkDedicatedAllocationMemoryAllocateInfoNV::safe_VkDedicatedAllocationMemoryAllocateInfoNV(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDedicatedAllocationMemoryAllocateInfoNV& safe_VkDedicatedAllocationMemoryAllocateInfoNV::operator=(const safe_VkDedicatedAllocationMemoryAllocateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     image = src.image;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDedicatedAllocationMemoryAllocateInfoNV::~safe_VkDedicatedAllocationMemoryAllocateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const VkDedicatedAllocationMemoryAllocateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     image = in_struct->image;
     buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDedicatedAllocationMemoryAllocateInfoNV::initialize(const safe_VkDedicatedAllocationMemoryAllocateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     image = src->image;
     buffer = src->buffer;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     transformFeedback(in_struct->transformFeedback),
     geometryStreams(in_struct->geometryStreams)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT()
+safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     transformFeedback = src.transformFeedback;
     geometryStreams = src.geometryStreams;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::operator=(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     transformFeedback = src.transformFeedback;
     geometryStreams = src.geometryStreams;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::~safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize(const VkPhysicalDeviceTransformFeedbackFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     transformFeedback = in_struct->transformFeedback;
     geometryStreams = in_struct->geometryStreams;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT::initialize(const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     transformFeedback = src->transformFeedback;
     geometryStreams = src->geometryStreams;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxTransformFeedbackStreams(in_struct->maxTransformFeedbackStreams),
     maxTransformFeedbackBuffers(in_struct->maxTransformFeedbackBuffers),
     maxTransformFeedbackBufferSize(in_struct->maxTransformFeedbackBufferSize),
@@ -14679,15 +16098,16 @@ safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransf
     transformFeedbackRasterizationStreamSelect(in_struct->transformFeedbackRasterizationStreamSelect),
     transformFeedbackDraw(in_struct->transformFeedbackDraw)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT()
+safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxTransformFeedbackStreams = src.maxTransformFeedbackStreams;
     maxTransformFeedbackBuffers = src.maxTransformFeedbackBuffers;
     maxTransformFeedbackBufferSize = src.maxTransformFeedbackBufferSize;
@@ -14698,15 +16118,17 @@ safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::safe_VkPhysicalDeviceTransf
     transformFeedbackStreamsLinesTriangles = src.transformFeedbackStreamsLinesTriangles;
     transformFeedbackRasterizationStreamSelect = src.transformFeedbackRasterizationStreamSelect;
     transformFeedbackDraw = src.transformFeedbackDraw;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::operator=(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxTransformFeedbackStreams = src.maxTransformFeedbackStreams;
     maxTransformFeedbackBuffers = src.maxTransformFeedbackBuffers;
     maxTransformFeedbackBufferSize = src.maxTransformFeedbackBufferSize;
@@ -14717,18 +16139,20 @@ safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT& safe_VkPhysicalDeviceTransf
     transformFeedbackStreamsLinesTriangles = src.transformFeedbackStreamsLinesTriangles;
     transformFeedbackRasterizationStreamSelect = src.transformFeedbackRasterizationStreamSelect;
     transformFeedbackDraw = src.transformFeedbackDraw;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::~safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(const VkPhysicalDeviceTransformFeedbackPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxTransformFeedbackStreams = in_struct->maxTransformFeedbackStreams;
     maxTransformFeedbackBuffers = in_struct->maxTransformFeedbackBuffers;
     maxTransformFeedbackBufferSize = in_struct->maxTransformFeedbackBufferSize;
@@ -14739,12 +16163,12 @@ void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(const VkPhy
     transformFeedbackStreamsLinesTriangles = in_struct->transformFeedbackStreamsLinesTriangles;
     transformFeedbackRasterizationStreamSelect = in_struct->transformFeedbackRasterizationStreamSelect;
     transformFeedbackDraw = in_struct->transformFeedbackDraw;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxTransformFeedbackStreams = src->maxTransformFeedbackStreams;
     maxTransformFeedbackBuffers = src->maxTransformFeedbackBuffers;
     maxTransformFeedbackBufferSize = src->maxTransformFeedbackBufferSize;
@@ -14755,413 +16179,454 @@ void safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT::initialize(const safe_
     transformFeedbackStreamsLinesTriangles = src->transformFeedbackStreamsLinesTriangles;
     transformFeedbackRasterizationStreamSelect = src->transformFeedbackRasterizationStreamSelect;
     transformFeedbackDraw = src->transformFeedbackDraw;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     rasterizationStream(in_struct->rasterizationStream)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT()
+safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineRasterizationStateStreamCreateInfoEXT::safe_VkPipelineRasterizationStateStreamCreateInfoEXT(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     rasterizationStream = src.rasterizationStream;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineRasterizationStateStreamCreateInfoEXT& safe_VkPipelineRasterizationStateStreamCreateInfoEXT::operator=(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     rasterizationStream = src.rasterizationStream;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineRasterizationStateStreamCreateInfoEXT::~safe_VkPipelineRasterizationStateStreamCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize(const VkPipelineRasterizationStateStreamCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     rasterizationStream = in_struct->rasterizationStream;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineRasterizationStateStreamCreateInfoEXT::initialize(const safe_VkPipelineRasterizationStateStreamCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     rasterizationStream = src->rasterizationStream;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const VkImageViewHandleInfoNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     imageView(in_struct->imageView),
     descriptorType(in_struct->descriptorType),
     sampler(in_struct->sampler)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX()
+safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX() :
+    pNext(nullptr)
 {}
 
 safe_VkImageViewHandleInfoNVX::safe_VkImageViewHandleInfoNVX(const safe_VkImageViewHandleInfoNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     imageView = src.imageView;
     descriptorType = src.descriptorType;
     sampler = src.sampler;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageViewHandleInfoNVX& safe_VkImageViewHandleInfoNVX::operator=(const safe_VkImageViewHandleInfoNVX& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     imageView = src.imageView;
     descriptorType = src.descriptorType;
     sampler = src.sampler;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageViewHandleInfoNVX::~safe_VkImageViewHandleInfoNVX()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageViewHandleInfoNVX::initialize(const VkImageViewHandleInfoNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     imageView = in_struct->imageView;
     descriptorType = in_struct->descriptorType;
     sampler = in_struct->sampler;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageViewHandleInfoNVX::initialize(const safe_VkImageViewHandleInfoNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     imageView = src->imageView;
     descriptorType = src->descriptorType;
     sampler = src->sampler;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(const VkTextureLODGatherFormatPropertiesAMD* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     supportsTextureGatherLODBiasAMD(in_struct->supportsTextureGatherLODBiasAMD)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD()
+safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD() :
+    pNext(nullptr)
 {}
 
 safe_VkTextureLODGatherFormatPropertiesAMD::safe_VkTextureLODGatherFormatPropertiesAMD(const safe_VkTextureLODGatherFormatPropertiesAMD& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     supportsTextureGatherLODBiasAMD = src.supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkTextureLODGatherFormatPropertiesAMD& safe_VkTextureLODGatherFormatPropertiesAMD::operator=(const safe_VkTextureLODGatherFormatPropertiesAMD& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     supportsTextureGatherLODBiasAMD = src.supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkTextureLODGatherFormatPropertiesAMD::~safe_VkTextureLODGatherFormatPropertiesAMD()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const VkTextureLODGatherFormatPropertiesAMD* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     supportsTextureGatherLODBiasAMD = in_struct->supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkTextureLODGatherFormatPropertiesAMD::initialize(const safe_VkTextureLODGatherFormatPropertiesAMD* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     supportsTextureGatherLODBiasAMD = src->supportsTextureGatherLODBiasAMD;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_GGP
 
 
 safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     streamDescriptor(in_struct->streamDescriptor)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP()
+safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP() :
+    pNext(nullptr)
 {}
 
 safe_VkStreamDescriptorSurfaceCreateInfoGGP::safe_VkStreamDescriptorSurfaceCreateInfoGGP(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     streamDescriptor = src.streamDescriptor;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkStreamDescriptorSurfaceCreateInfoGGP& safe_VkStreamDescriptorSurfaceCreateInfoGGP::operator=(const safe_VkStreamDescriptorSurfaceCreateInfoGGP& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     streamDescriptor = src.streamDescriptor;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkStreamDescriptorSurfaceCreateInfoGGP::~safe_VkStreamDescriptorSurfaceCreateInfoGGP()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const VkStreamDescriptorSurfaceCreateInfoGGP* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     streamDescriptor = in_struct->streamDescriptor;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkStreamDescriptorSurfaceCreateInfoGGP::initialize(const safe_VkStreamDescriptorSurfaceCreateInfoGGP* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     streamDescriptor = src->streamDescriptor;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_GGP
 
 
 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     cornerSampledImage(in_struct->cornerSampledImage)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV()
+safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     cornerSampledImage = src.cornerSampledImage;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::operator=(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     cornerSampledImage = src.cornerSampledImage;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::~safe_VkPhysicalDeviceCornerSampledImageFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize(const VkPhysicalDeviceCornerSampledImageFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     cornerSampledImage = in_struct->cornerSampledImage;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceCornerSampledImageFeaturesNV::initialize(const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     cornerSampledImage = src->cornerSampledImage;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const VkExternalMemoryImageCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleTypes(in_struct->handleTypes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV()
+safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalMemoryImageCreateInfoNV::safe_VkExternalMemoryImageCreateInfoNV(const safe_VkExternalMemoryImageCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalMemoryImageCreateInfoNV& safe_VkExternalMemoryImageCreateInfoNV::operator=(const safe_VkExternalMemoryImageCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalMemoryImageCreateInfoNV::~safe_VkExternalMemoryImageCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalMemoryImageCreateInfoNV::initialize(const VkExternalMemoryImageCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalMemoryImageCreateInfoNV::initialize(const safe_VkExternalMemoryImageCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleTypes = src->handleTypes;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const VkExportMemoryAllocateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleTypes(in_struct->handleTypes)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV()
+safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkExportMemoryAllocateInfoNV::safe_VkExportMemoryAllocateInfoNV(const safe_VkExportMemoryAllocateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExportMemoryAllocateInfoNV& safe_VkExportMemoryAllocateInfoNV::operator=(const safe_VkExportMemoryAllocateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleTypes = src.handleTypes;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExportMemoryAllocateInfoNV::~safe_VkExportMemoryAllocateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportMemoryAllocateInfoNV::initialize(const VkExportMemoryAllocateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleTypes = in_struct->handleTypes;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExportMemoryAllocateInfoNV::initialize(const safe_VkExportMemoryAllocateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleTypes = src->handleTypes;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const VkImportMemoryWin32HandleInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleType(in_struct->handleType),
     handle(in_struct->handle)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV()
+safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkImportMemoryWin32HandleInfoNV::safe_VkImportMemoryWin32HandleInfoNV(const safe_VkImportMemoryWin32HandleInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     handle = src.handle;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportMemoryWin32HandleInfoNV& safe_VkImportMemoryWin32HandleInfoNV::operator=(const safe_VkImportMemoryWin32HandleInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     handle = src.handle;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportMemoryWin32HandleInfoNV::~safe_VkImportMemoryWin32HandleInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportMemoryWin32HandleInfoNV::initialize(const VkImportMemoryWin32HandleInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleType = in_struct->handleType;
     handle = in_struct->handle;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportMemoryWin32HandleInfoNV::initialize(const safe_VkImportMemoryWin32HandleInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleType = src->handleType;
     handle = src->handle;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -15170,25 +16635,26 @@ void safe_VkImportMemoryWin32HandleInfoNV::initialize(const safe_VkImportMemoryW
 
 safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const VkExportMemoryWin32HandleInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pAttributes(nullptr),
     dwAccess(in_struct->dwAccess)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
 }
 
 safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV() :
+    pNext(nullptr),
     pAttributes(nullptr)
 {}
 
 safe_VkExportMemoryWin32HandleInfoNV::safe_VkExportMemoryWin32HandleInfoNV(const safe_VkExportMemoryWin32HandleInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -15200,11 +16666,13 @@ safe_VkExportMemoryWin32HandleInfoNV& safe_VkExportMemoryWin32HandleInfoNV::oper
 
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pAttributes = nullptr;
     dwAccess = src.dwAccess;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src.pAttributes);
     }
@@ -15216,14 +16684,16 @@ safe_VkExportMemoryWin32HandleInfoNV::~safe_VkExportMemoryWin32HandleInfoNV()
 {
     if (pAttributes)
         delete pAttributes;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExportMemoryWin32HandleInfoNV::initialize(const VkExportMemoryWin32HandleInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pAttributes = nullptr;
     dwAccess = in_struct->dwAccess;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*in_struct->pAttributes);
     }
@@ -15232,9 +16702,9 @@ void safe_VkExportMemoryWin32HandleInfoNV::initialize(const VkExportMemoryWin32H
 void safe_VkExportMemoryWin32HandleInfoNV::initialize(const safe_VkExportMemoryWin32HandleInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pAttributes = nullptr;
     dwAccess = src->dwAccess;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAttributes) {
         pAttributes = new SECURITY_ATTRIBUTES(*src->pAttributes);
     }
@@ -15246,7 +16716,6 @@ void safe_VkExportMemoryWin32HandleInfoNV::initialize(const safe_VkExportMemoryW
 
 safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     acquireCount(in_struct->acquireCount),
     pAcquireSyncs(nullptr),
     pAcquireKeys(nullptr),
@@ -15255,9 +16724,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireRelease
     pReleaseSyncs(nullptr),
     pReleaseKeys(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (acquireCount && in_struct->pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
         }
     }
@@ -15271,7 +16741,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireRelease
     }
     if (releaseCount && in_struct->pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
         }
     }
@@ -15282,6 +16752,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireRelease
 }
 
 safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV() :
+    pNext(nullptr),
     pAcquireSyncs(nullptr),
     pAcquireKeys(nullptr),
     pAcquireTimeoutMilliseconds(nullptr),
@@ -15292,7 +16763,6 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireRelease
 safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireReleaseInfoNV(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     acquireCount = src.acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -15300,9 +16770,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireRelease
     releaseCount = src.releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (acquireCount && src.pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = src.pAcquireSyncs[i];
         }
     }
@@ -15316,7 +16787,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV::safe_VkWin32KeyedMutexAcquireRelease
     }
     if (releaseCount && src.pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = src.pReleaseSyncs[i];
         }
     }
@@ -15340,9 +16811,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV& safe_VkWin32KeyedMutexAcquireRelease
         delete[] pReleaseSyncs;
     if (pReleaseKeys)
         delete[] pReleaseKeys;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     acquireCount = src.acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -15350,9 +16822,10 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV& safe_VkWin32KeyedMutexAcquireRelease
     releaseCount = src.releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (acquireCount && src.pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = src.pAcquireSyncs[i];
         }
     }
@@ -15366,7 +16839,7 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV& safe_VkWin32KeyedMutexAcquireRelease
     }
     if (releaseCount && src.pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = src.pReleaseSyncs[i];
         }
     }
@@ -15390,12 +16863,13 @@ safe_VkWin32KeyedMutexAcquireReleaseInfoNV::~safe_VkWin32KeyedMutexAcquireReleas
         delete[] pReleaseSyncs;
     if (pReleaseKeys)
         delete[] pReleaseKeys;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMutexAcquireReleaseInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     acquireCount = in_struct->acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -15403,9 +16877,10 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMu
     releaseCount = in_struct->releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (acquireCount && in_struct->pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = in_struct->pAcquireSyncs[i];
         }
     }
@@ -15419,7 +16894,7 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMu
     }
     if (releaseCount && in_struct->pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = in_struct->pReleaseSyncs[i];
         }
     }
@@ -15432,7 +16907,6 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const VkWin32KeyedMu
 void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32KeyedMutexAcquireReleaseInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     acquireCount = src->acquireCount;
     pAcquireSyncs = nullptr;
     pAcquireKeys = nullptr;
@@ -15440,9 +16914,10 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32Ke
     releaseCount = src->releaseCount;
     pReleaseSyncs = nullptr;
     pReleaseKeys = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (acquireCount && src->pAcquireSyncs) {
         pAcquireSyncs = new VkDeviceMemory[acquireCount];
-        for (uint32_t i=0; i<acquireCount; ++i) {
+        for (uint32_t i = 0; i < acquireCount; ++i) {
             pAcquireSyncs[i] = src->pAcquireSyncs[i];
         }
     }
@@ -15456,7 +16931,7 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32Ke
     }
     if (releaseCount && src->pReleaseSyncs) {
         pReleaseSyncs = new VkDeviceMemory[releaseCount];
-        for (uint32_t i=0; i<releaseCount; ++i) {
+        for (uint32_t i = 0; i < releaseCount; ++i) {
             pReleaseSyncs[i] = src->pReleaseSyncs[i];
         }
     }
@@ -15470,10 +16945,10 @@ void safe_VkWin32KeyedMutexAcquireReleaseInfoNV::initialize(const safe_VkWin32Ke
 
 safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const VkValidationFlagsEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     disabledValidationCheckCount(in_struct->disabledValidationCheckCount),
     pDisabledValidationChecks(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDisabledValidationChecks) {
         pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
         memcpy ((void *)pDisabledValidationChecks, (void *)in_struct->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*in_struct->disabledValidationCheckCount);
@@ -15481,15 +16956,16 @@ safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const VkValidationFlagsEXT*
 }
 
 safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT() :
+    pNext(nullptr),
     pDisabledValidationChecks(nullptr)
 {}
 
 safe_VkValidationFlagsEXT::safe_VkValidationFlagsEXT(const safe_VkValidationFlagsEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     disabledValidationCheckCount = src.disabledValidationCheckCount;
     pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDisabledValidationChecks) {
         pDisabledValidationChecks = new VkValidationCheckEXT[src.disabledValidationCheckCount];
         memcpy ((void *)pDisabledValidationChecks, (void *)src.pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*src.disabledValidationCheckCount);
@@ -15502,11 +16978,13 @@ safe_VkValidationFlagsEXT& safe_VkValidationFlagsEXT::operator=(const safe_VkVal
 
     if (pDisabledValidationChecks)
         delete[] pDisabledValidationChecks;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     disabledValidationCheckCount = src.disabledValidationCheckCount;
     pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDisabledValidationChecks) {
         pDisabledValidationChecks = new VkValidationCheckEXT[src.disabledValidationCheckCount];
         memcpy ((void *)pDisabledValidationChecks, (void *)src.pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*src.disabledValidationCheckCount);
@@ -15519,14 +16997,16 @@ safe_VkValidationFlagsEXT::~safe_VkValidationFlagsEXT()
 {
     if (pDisabledValidationChecks)
         delete[] pDisabledValidationChecks;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkValidationFlagsEXT::initialize(const VkValidationFlagsEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     disabledValidationCheckCount = in_struct->disabledValidationCheckCount;
     pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDisabledValidationChecks) {
         pDisabledValidationChecks = new VkValidationCheckEXT[in_struct->disabledValidationCheckCount];
         memcpy ((void *)pDisabledValidationChecks, (void *)in_struct->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*in_struct->disabledValidationCheckCount);
@@ -15536,9 +17016,9 @@ void safe_VkValidationFlagsEXT::initialize(const VkValidationFlagsEXT* in_struct
 void safe_VkValidationFlagsEXT::initialize(const safe_VkValidationFlagsEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     disabledValidationCheckCount = src->disabledValidationCheckCount;
     pDisabledValidationChecks = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDisabledValidationChecks) {
         pDisabledValidationChecks = new VkValidationCheckEXT[src->disabledValidationCheckCount];
         memcpy ((void *)pDisabledValidationChecks, (void *)src->pDisabledValidationChecks, sizeof(VkValidationCheckEXT)*src->disabledValidationCheckCount);
@@ -15549,430 +17029,523 @@ void safe_VkValidationFlagsEXT::initialize(const safe_VkValidationFlagsEXT* src)
 
 safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const VkViSurfaceCreateInfoNN* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     window(in_struct->window)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN()
+safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN() :
+    pNext(nullptr),
+    window(nullptr)
 {}
 
 safe_VkViSurfaceCreateInfoNN::safe_VkViSurfaceCreateInfoNN(const safe_VkViSurfaceCreateInfoNN& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     window = src.window;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkViSurfaceCreateInfoNN& safe_VkViSurfaceCreateInfoNN::operator=(const safe_VkViSurfaceCreateInfoNN& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     window = src.window;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkViSurfaceCreateInfoNN::~safe_VkViSurfaceCreateInfoNN()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkViSurfaceCreateInfoNN::initialize(const VkViSurfaceCreateInfoNN* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     window = in_struct->window;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkViSurfaceCreateInfoNN::initialize(const safe_VkViSurfaceCreateInfoNN* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     window = src->window;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_VI_NN
 
 
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct) :
+    sType(in_struct->sType),
+    textureCompressionASTC_HDR(in_struct->textureCompressionASTC_HDR)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src)
+{
+    sType = src.sType;
+    textureCompressionASTC_HDR = src.textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::operator=(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    textureCompressionASTC_HDR = src.textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct)
+{
+    sType = in_struct->sType;
+    textureCompressionASTC_HDR = in_struct->textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT::initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* src)
+{
+    sType = src->sType;
+    textureCompressionASTC_HDR = src->textureCompressionASTC_HDR;
+    pNext = SafePnextCopy(src->pNext);
+}
+
 safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const VkImageViewASTCDecodeModeEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     decodeMode(in_struct->decodeMode)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT()
+safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkImageViewASTCDecodeModeEXT::safe_VkImageViewASTCDecodeModeEXT(const safe_VkImageViewASTCDecodeModeEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     decodeMode = src.decodeMode;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageViewASTCDecodeModeEXT& safe_VkImageViewASTCDecodeModeEXT::operator=(const safe_VkImageViewASTCDecodeModeEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     decodeMode = src.decodeMode;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageViewASTCDecodeModeEXT::~safe_VkImageViewASTCDecodeModeEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageViewASTCDecodeModeEXT::initialize(const VkImageViewASTCDecodeModeEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     decodeMode = in_struct->decodeMode;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageViewASTCDecodeModeEXT::initialize(const safe_VkImageViewASTCDecodeModeEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     decodeMode = src->decodeMode;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     decodeModeSharedExponent(in_struct->decodeModeSharedExponent)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT()
+safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     decodeModeSharedExponent = src.decodeModeSharedExponent;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::operator=(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     decodeModeSharedExponent = src.decodeModeSharedExponent;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::~safe_VkPhysicalDeviceASTCDecodeFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const VkPhysicalDeviceASTCDecodeFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     decodeModeSharedExponent = in_struct->decodeModeSharedExponent;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceASTCDecodeFeaturesEXT::initialize(const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     decodeModeSharedExponent = src->decodeModeSharedExponent;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT(const VkConditionalRenderingBeginInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     buffer(in_struct->buffer),
     offset(in_struct->offset),
     flags(in_struct->flags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT()
+safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkConditionalRenderingBeginInfoEXT::safe_VkConditionalRenderingBeginInfoEXT(const safe_VkConditionalRenderingBeginInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
     offset = src.offset;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkConditionalRenderingBeginInfoEXT& safe_VkConditionalRenderingBeginInfoEXT::operator=(const safe_VkConditionalRenderingBeginInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
     offset = src.offset;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkConditionalRenderingBeginInfoEXT::~safe_VkConditionalRenderingBeginInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkConditionalRenderingBeginInfoEXT::initialize(const VkConditionalRenderingBeginInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     buffer = in_struct->buffer;
     offset = in_struct->offset;
     flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkConditionalRenderingBeginInfoEXT::initialize(const safe_VkConditionalRenderingBeginInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     buffer = src->buffer;
     offset = src->offset;
     flags = src->flags;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     conditionalRendering(in_struct->conditionalRendering),
     inheritedConditionalRendering(in_struct->inheritedConditionalRendering)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT()
+safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     conditionalRendering = src.conditionalRendering;
     inheritedConditionalRendering = src.inheritedConditionalRendering;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::operator=(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     conditionalRendering = src.conditionalRendering;
     inheritedConditionalRendering = src.inheritedConditionalRendering;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::~safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize(const VkPhysicalDeviceConditionalRenderingFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     conditionalRendering = in_struct->conditionalRendering;
     inheritedConditionalRendering = in_struct->inheritedConditionalRendering;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT::initialize(const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     conditionalRendering = src->conditionalRendering;
     inheritedConditionalRendering = src->inheritedConditionalRendering;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     conditionalRenderingEnable(in_struct->conditionalRenderingEnable)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT()
+safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     conditionalRenderingEnable = src.conditionalRenderingEnable;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::operator=(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     conditionalRenderingEnable = src.conditionalRenderingEnable;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::~safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize(const VkCommandBufferInheritanceConditionalRenderingInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     conditionalRenderingEnable = in_struct->conditionalRenderingEnable;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT::initialize(const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     conditionalRenderingEnable = src->conditionalRenderingEnable;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceGeneratedCommandsFeaturesNVX::safe_VkDeviceGeneratedCommandsFeaturesNVX(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     computeBindingPointSupport(in_struct->computeBindingPointSupport)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceGeneratedCommandsFeaturesNVX::safe_VkDeviceGeneratedCommandsFeaturesNVX()
+safe_VkDeviceGeneratedCommandsFeaturesNVX::safe_VkDeviceGeneratedCommandsFeaturesNVX() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceGeneratedCommandsFeaturesNVX::safe_VkDeviceGeneratedCommandsFeaturesNVX(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     computeBindingPointSupport = src.computeBindingPointSupport;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceGeneratedCommandsFeaturesNVX& safe_VkDeviceGeneratedCommandsFeaturesNVX::operator=(const safe_VkDeviceGeneratedCommandsFeaturesNVX& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     computeBindingPointSupport = src.computeBindingPointSupport;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceGeneratedCommandsFeaturesNVX::~safe_VkDeviceGeneratedCommandsFeaturesNVX()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGeneratedCommandsFeaturesNVX::initialize(const VkDeviceGeneratedCommandsFeaturesNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     computeBindingPointSupport = in_struct->computeBindingPointSupport;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceGeneratedCommandsFeaturesNVX::initialize(const safe_VkDeviceGeneratedCommandsFeaturesNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     computeBindingPointSupport = src->computeBindingPointSupport;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceGeneratedCommandsLimitsNVX::safe_VkDeviceGeneratedCommandsLimitsNVX(const VkDeviceGeneratedCommandsLimitsNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxIndirectCommandsLayoutTokenCount(in_struct->maxIndirectCommandsLayoutTokenCount),
     maxObjectEntryCounts(in_struct->maxObjectEntryCounts),
     minSequenceCountBufferOffsetAlignment(in_struct->minSequenceCountBufferOffsetAlignment),
     minSequenceIndexBufferOffsetAlignment(in_struct->minSequenceIndexBufferOffsetAlignment),
     minCommandsTokenBufferOffsetAlignment(in_struct->minCommandsTokenBufferOffsetAlignment)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceGeneratedCommandsLimitsNVX::safe_VkDeviceGeneratedCommandsLimitsNVX()
+safe_VkDeviceGeneratedCommandsLimitsNVX::safe_VkDeviceGeneratedCommandsLimitsNVX() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceGeneratedCommandsLimitsNVX::safe_VkDeviceGeneratedCommandsLimitsNVX(const safe_VkDeviceGeneratedCommandsLimitsNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxIndirectCommandsLayoutTokenCount = src.maxIndirectCommandsLayoutTokenCount;
     maxObjectEntryCounts = src.maxObjectEntryCounts;
     minSequenceCountBufferOffsetAlignment = src.minSequenceCountBufferOffsetAlignment;
     minSequenceIndexBufferOffsetAlignment = src.minSequenceIndexBufferOffsetAlignment;
     minCommandsTokenBufferOffsetAlignment = src.minCommandsTokenBufferOffsetAlignment;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceGeneratedCommandsLimitsNVX& safe_VkDeviceGeneratedCommandsLimitsNVX::operator=(const safe_VkDeviceGeneratedCommandsLimitsNVX& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxIndirectCommandsLayoutTokenCount = src.maxIndirectCommandsLayoutTokenCount;
     maxObjectEntryCounts = src.maxObjectEntryCounts;
     minSequenceCountBufferOffsetAlignment = src.minSequenceCountBufferOffsetAlignment;
     minSequenceIndexBufferOffsetAlignment = src.minSequenceIndexBufferOffsetAlignment;
     minCommandsTokenBufferOffsetAlignment = src.minCommandsTokenBufferOffsetAlignment;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceGeneratedCommandsLimitsNVX::~safe_VkDeviceGeneratedCommandsLimitsNVX()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceGeneratedCommandsLimitsNVX::initialize(const VkDeviceGeneratedCommandsLimitsNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxIndirectCommandsLayoutTokenCount = in_struct->maxIndirectCommandsLayoutTokenCount;
     maxObjectEntryCounts = in_struct->maxObjectEntryCounts;
     minSequenceCountBufferOffsetAlignment = in_struct->minSequenceCountBufferOffsetAlignment;
     minSequenceIndexBufferOffsetAlignment = in_struct->minSequenceIndexBufferOffsetAlignment;
     minCommandsTokenBufferOffsetAlignment = in_struct->minCommandsTokenBufferOffsetAlignment;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceGeneratedCommandsLimitsNVX::initialize(const safe_VkDeviceGeneratedCommandsLimitsNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxIndirectCommandsLayoutTokenCount = src->maxIndirectCommandsLayoutTokenCount;
     maxObjectEntryCounts = src->maxObjectEntryCounts;
     minSequenceCountBufferOffsetAlignment = src->minSequenceCountBufferOffsetAlignment;
     minSequenceIndexBufferOffsetAlignment = src->minSequenceIndexBufferOffsetAlignment;
     minCommandsTokenBufferOffsetAlignment = src->minCommandsTokenBufferOffsetAlignment;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkIndirectCommandsLayoutCreateInfoNVX::safe_VkIndirectCommandsLayoutCreateInfoNVX(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pipelineBindPoint(in_struct->pipelineBindPoint),
     flags(in_struct->flags),
     tokenCount(in_struct->tokenCount),
     pTokens(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pTokens) {
         pTokens = new VkIndirectCommandsLayoutTokenNVX[in_struct->tokenCount];
         memcpy ((void *)pTokens, (void *)in_struct->pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*in_struct->tokenCount);
@@ -15980,17 +17553,18 @@ safe_VkIndirectCommandsLayoutCreateInfoNVX::safe_VkIndirectCommandsLayoutCreateI
 }
 
 safe_VkIndirectCommandsLayoutCreateInfoNVX::safe_VkIndirectCommandsLayoutCreateInfoNVX() :
+    pNext(nullptr),
     pTokens(nullptr)
 {}
 
 safe_VkIndirectCommandsLayoutCreateInfoNVX::safe_VkIndirectCommandsLayoutCreateInfoNVX(const safe_VkIndirectCommandsLayoutCreateInfoNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pipelineBindPoint = src.pipelineBindPoint;
     flags = src.flags;
     tokenCount = src.tokenCount;
     pTokens = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pTokens) {
         pTokens = new VkIndirectCommandsLayoutTokenNVX[src.tokenCount];
         memcpy ((void *)pTokens, (void *)src.pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*src.tokenCount);
@@ -16003,13 +17577,15 @@ safe_VkIndirectCommandsLayoutCreateInfoNVX& safe_VkIndirectCommandsLayoutCreateI
 
     if (pTokens)
         delete[] pTokens;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pipelineBindPoint = src.pipelineBindPoint;
     flags = src.flags;
     tokenCount = src.tokenCount;
     pTokens = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pTokens) {
         pTokens = new VkIndirectCommandsLayoutTokenNVX[src.tokenCount];
         memcpy ((void *)pTokens, (void *)src.pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*src.tokenCount);
@@ -16022,16 +17598,18 @@ safe_VkIndirectCommandsLayoutCreateInfoNVX::~safe_VkIndirectCommandsLayoutCreate
 {
     if (pTokens)
         delete[] pTokens;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkIndirectCommandsLayoutCreateInfoNVX::initialize(const VkIndirectCommandsLayoutCreateInfoNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pipelineBindPoint = in_struct->pipelineBindPoint;
     flags = in_struct->flags;
     tokenCount = in_struct->tokenCount;
     pTokens = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pTokens) {
         pTokens = new VkIndirectCommandsLayoutTokenNVX[in_struct->tokenCount];
         memcpy ((void *)pTokens, (void *)in_struct->pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*in_struct->tokenCount);
@@ -16041,11 +17619,11 @@ void safe_VkIndirectCommandsLayoutCreateInfoNVX::initialize(const VkIndirectComm
 void safe_VkIndirectCommandsLayoutCreateInfoNVX::initialize(const safe_VkIndirectCommandsLayoutCreateInfoNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pipelineBindPoint = src->pipelineBindPoint;
     flags = src->flags;
     tokenCount = src->tokenCount;
     pTokens = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pTokens) {
         pTokens = new VkIndirectCommandsLayoutTokenNVX[src->tokenCount];
         memcpy ((void *)pTokens, (void *)src->pTokens, sizeof(VkIndirectCommandsLayoutTokenNVX)*src->tokenCount);
@@ -16054,7 +17632,6 @@ void safe_VkIndirectCommandsLayoutCreateInfoNVX::initialize(const safe_VkIndirec
 
 safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX(const VkCmdProcessCommandsInfoNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     objectTable(in_struct->objectTable),
     indirectCommandsLayout(in_struct->indirectCommandsLayout),
     indirectCommandsTokenCount(in_struct->indirectCommandsTokenCount),
@@ -16066,22 +17643,23 @@ safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX(const VkCmdPr
     sequencesIndexBuffer(in_struct->sequencesIndexBuffer),
     sequencesIndexOffset(in_struct->sequencesIndexOffset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (indirectCommandsTokenCount && in_struct->pIndirectCommandsTokens) {
         pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
-        for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+        for (uint32_t i = 0; i < indirectCommandsTokenCount; ++i) {
             pIndirectCommandsTokens[i] = in_struct->pIndirectCommandsTokens[i];
         }
     }
 }
 
 safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX() :
+    pNext(nullptr),
     pIndirectCommandsTokens(nullptr)
 {}
 
 safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX(const safe_VkCmdProcessCommandsInfoNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     objectTable = src.objectTable;
     indirectCommandsLayout = src.indirectCommandsLayout;
     indirectCommandsTokenCount = src.indirectCommandsTokenCount;
@@ -16092,9 +17670,10 @@ safe_VkCmdProcessCommandsInfoNVX::safe_VkCmdProcessCommandsInfoNVX(const safe_Vk
     sequencesCountOffset = src.sequencesCountOffset;
     sequencesIndexBuffer = src.sequencesIndexBuffer;
     sequencesIndexOffset = src.sequencesIndexOffset;
+    pNext = SafePnextCopy(src.pNext);
     if (indirectCommandsTokenCount && src.pIndirectCommandsTokens) {
         pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
-        for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+        for (uint32_t i = 0; i < indirectCommandsTokenCount; ++i) {
             pIndirectCommandsTokens[i] = src.pIndirectCommandsTokens[i];
         }
     }
@@ -16106,9 +17685,10 @@ safe_VkCmdProcessCommandsInfoNVX& safe_VkCmdProcessCommandsInfoNVX::operator=(co
 
     if (pIndirectCommandsTokens)
         delete[] pIndirectCommandsTokens;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     objectTable = src.objectTable;
     indirectCommandsLayout = src.indirectCommandsLayout;
     indirectCommandsTokenCount = src.indirectCommandsTokenCount;
@@ -16119,9 +17699,10 @@ safe_VkCmdProcessCommandsInfoNVX& safe_VkCmdProcessCommandsInfoNVX::operator=(co
     sequencesCountOffset = src.sequencesCountOffset;
     sequencesIndexBuffer = src.sequencesIndexBuffer;
     sequencesIndexOffset = src.sequencesIndexOffset;
+    pNext = SafePnextCopy(src.pNext);
     if (indirectCommandsTokenCount && src.pIndirectCommandsTokens) {
         pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
-        for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+        for (uint32_t i = 0; i < indirectCommandsTokenCount; ++i) {
             pIndirectCommandsTokens[i] = src.pIndirectCommandsTokens[i];
         }
     }
@@ -16133,12 +17714,13 @@ safe_VkCmdProcessCommandsInfoNVX::~safe_VkCmdProcessCommandsInfoNVX()
 {
     if (pIndirectCommandsTokens)
         delete[] pIndirectCommandsTokens;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCmdProcessCommandsInfoNVX::initialize(const VkCmdProcessCommandsInfoNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     objectTable = in_struct->objectTable;
     indirectCommandsLayout = in_struct->indirectCommandsLayout;
     indirectCommandsTokenCount = in_struct->indirectCommandsTokenCount;
@@ -16149,9 +17731,10 @@ void safe_VkCmdProcessCommandsInfoNVX::initialize(const VkCmdProcessCommandsInfo
     sequencesCountOffset = in_struct->sequencesCountOffset;
     sequencesIndexBuffer = in_struct->sequencesIndexBuffer;
     sequencesIndexOffset = in_struct->sequencesIndexOffset;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (indirectCommandsTokenCount && in_struct->pIndirectCommandsTokens) {
         pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
-        for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+        for (uint32_t i = 0; i < indirectCommandsTokenCount; ++i) {
             pIndirectCommandsTokens[i] = in_struct->pIndirectCommandsTokens[i];
         }
     }
@@ -16160,7 +17743,6 @@ void safe_VkCmdProcessCommandsInfoNVX::initialize(const VkCmdProcessCommandsInfo
 void safe_VkCmdProcessCommandsInfoNVX::initialize(const safe_VkCmdProcessCommandsInfoNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     objectTable = src->objectTable;
     indirectCommandsLayout = src->indirectCommandsLayout;
     indirectCommandsTokenCount = src->indirectCommandsTokenCount;
@@ -16171,9 +17753,10 @@ void safe_VkCmdProcessCommandsInfoNVX::initialize(const safe_VkCmdProcessCommand
     sequencesCountOffset = src->sequencesCountOffset;
     sequencesIndexBuffer = src->sequencesIndexBuffer;
     sequencesIndexOffset = src->sequencesIndexOffset;
+    pNext = SafePnextCopy(src->pNext);
     if (indirectCommandsTokenCount && src->pIndirectCommandsTokens) {
         pIndirectCommandsTokens = new VkIndirectCommandsTokenNVX[indirectCommandsTokenCount];
-        for (uint32_t i=0; i<indirectCommandsTokenCount; ++i) {
+        for (uint32_t i = 0; i < indirectCommandsTokenCount; ++i) {
             pIndirectCommandsTokens[i] = src->pIndirectCommandsTokens[i];
         }
     }
@@ -16181,64 +17764,68 @@ void safe_VkCmdProcessCommandsInfoNVX::initialize(const safe_VkCmdProcessCommand
 
 safe_VkCmdReserveSpaceForCommandsInfoNVX::safe_VkCmdReserveSpaceForCommandsInfoNVX(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     objectTable(in_struct->objectTable),
     indirectCommandsLayout(in_struct->indirectCommandsLayout),
     maxSequencesCount(in_struct->maxSequencesCount)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCmdReserveSpaceForCommandsInfoNVX::safe_VkCmdReserveSpaceForCommandsInfoNVX()
+safe_VkCmdReserveSpaceForCommandsInfoNVX::safe_VkCmdReserveSpaceForCommandsInfoNVX() :
+    pNext(nullptr)
 {}
 
 safe_VkCmdReserveSpaceForCommandsInfoNVX::safe_VkCmdReserveSpaceForCommandsInfoNVX(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     objectTable = src.objectTable;
     indirectCommandsLayout = src.indirectCommandsLayout;
     maxSequencesCount = src.maxSequencesCount;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCmdReserveSpaceForCommandsInfoNVX& safe_VkCmdReserveSpaceForCommandsInfoNVX::operator=(const safe_VkCmdReserveSpaceForCommandsInfoNVX& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     objectTable = src.objectTable;
     indirectCommandsLayout = src.indirectCommandsLayout;
     maxSequencesCount = src.maxSequencesCount;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCmdReserveSpaceForCommandsInfoNVX::~safe_VkCmdReserveSpaceForCommandsInfoNVX()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCmdReserveSpaceForCommandsInfoNVX::initialize(const VkCmdReserveSpaceForCommandsInfoNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     objectTable = in_struct->objectTable;
     indirectCommandsLayout = in_struct->indirectCommandsLayout;
     maxSequencesCount = in_struct->maxSequencesCount;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCmdReserveSpaceForCommandsInfoNVX::initialize(const safe_VkCmdReserveSpaceForCommandsInfoNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     objectTable = src->objectTable;
     indirectCommandsLayout = src->indirectCommandsLayout;
     maxSequencesCount = src->maxSequencesCount;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX(const VkObjectTableCreateInfoNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     objectCount(in_struct->objectCount),
     pObjectEntryTypes(nullptr),
     pObjectEntryCounts(nullptr),
@@ -16249,6 +17836,7 @@ safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX(const VkObjectT
     maxSampledImagesPerDescriptor(in_struct->maxSampledImagesPerDescriptor),
     maxPipelineLayouts(in_struct->maxPipelineLayouts)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pObjectEntryTypes) {
         pObjectEntryTypes = new VkObjectEntryTypeNVX[in_struct->objectCount];
         memcpy ((void *)pObjectEntryTypes, (void *)in_struct->pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*in_struct->objectCount);
@@ -16264,6 +17852,7 @@ safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX(const VkObjectT
 }
 
 safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX() :
+    pNext(nullptr),
     pObjectEntryTypes(nullptr),
     pObjectEntryCounts(nullptr),
     pObjectEntryUsageFlags(nullptr)
@@ -16272,7 +17861,6 @@ safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX() :
 safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX(const safe_VkObjectTableCreateInfoNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     objectCount = src.objectCount;
     pObjectEntryTypes = nullptr;
     pObjectEntryCounts = nullptr;
@@ -16282,6 +17870,7 @@ safe_VkObjectTableCreateInfoNVX::safe_VkObjectTableCreateInfoNVX(const safe_VkOb
     maxStorageImagesPerDescriptor = src.maxStorageImagesPerDescriptor;
     maxSampledImagesPerDescriptor = src.maxSampledImagesPerDescriptor;
     maxPipelineLayouts = src.maxPipelineLayouts;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pObjectEntryTypes) {
         pObjectEntryTypes = new VkObjectEntryTypeNVX[src.objectCount];
         memcpy ((void *)pObjectEntryTypes, (void *)src.pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*src.objectCount);
@@ -16306,9 +17895,10 @@ safe_VkObjectTableCreateInfoNVX& safe_VkObjectTableCreateInfoNVX::operator=(cons
         delete[] pObjectEntryCounts;
     if (pObjectEntryUsageFlags)
         delete[] pObjectEntryUsageFlags;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     objectCount = src.objectCount;
     pObjectEntryTypes = nullptr;
     pObjectEntryCounts = nullptr;
@@ -16318,6 +17908,7 @@ safe_VkObjectTableCreateInfoNVX& safe_VkObjectTableCreateInfoNVX::operator=(cons
     maxStorageImagesPerDescriptor = src.maxStorageImagesPerDescriptor;
     maxSampledImagesPerDescriptor = src.maxSampledImagesPerDescriptor;
     maxPipelineLayouts = src.maxPipelineLayouts;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pObjectEntryTypes) {
         pObjectEntryTypes = new VkObjectEntryTypeNVX[src.objectCount];
         memcpy ((void *)pObjectEntryTypes, (void *)src.pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*src.objectCount);
@@ -16342,12 +17933,13 @@ safe_VkObjectTableCreateInfoNVX::~safe_VkObjectTableCreateInfoNVX()
         delete[] pObjectEntryCounts;
     if (pObjectEntryUsageFlags)
         delete[] pObjectEntryUsageFlags;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkObjectTableCreateInfoNVX::initialize(const VkObjectTableCreateInfoNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     objectCount = in_struct->objectCount;
     pObjectEntryTypes = nullptr;
     pObjectEntryCounts = nullptr;
@@ -16357,6 +17949,7 @@ void safe_VkObjectTableCreateInfoNVX::initialize(const VkObjectTableCreateInfoNV
     maxStorageImagesPerDescriptor = in_struct->maxStorageImagesPerDescriptor;
     maxSampledImagesPerDescriptor = in_struct->maxSampledImagesPerDescriptor;
     maxPipelineLayouts = in_struct->maxPipelineLayouts;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pObjectEntryTypes) {
         pObjectEntryTypes = new VkObjectEntryTypeNVX[in_struct->objectCount];
         memcpy ((void *)pObjectEntryTypes, (void *)in_struct->pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*in_struct->objectCount);
@@ -16374,7 +17967,6 @@ void safe_VkObjectTableCreateInfoNVX::initialize(const VkObjectTableCreateInfoNV
 void safe_VkObjectTableCreateInfoNVX::initialize(const safe_VkObjectTableCreateInfoNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     objectCount = src->objectCount;
     pObjectEntryTypes = nullptr;
     pObjectEntryCounts = nullptr;
@@ -16384,6 +17976,7 @@ void safe_VkObjectTableCreateInfoNVX::initialize(const safe_VkObjectTableCreateI
     maxStorageImagesPerDescriptor = src->maxStorageImagesPerDescriptor;
     maxSampledImagesPerDescriptor = src->maxSampledImagesPerDescriptor;
     maxPipelineLayouts = src->maxPipelineLayouts;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pObjectEntryTypes) {
         pObjectEntryTypes = new VkObjectEntryTypeNVX[src->objectCount];
         memcpy ((void *)pObjectEntryTypes, (void *)src->pObjectEntryTypes, sizeof(VkObjectEntryTypeNVX)*src->objectCount);
@@ -16400,11 +17993,11 @@ void safe_VkObjectTableCreateInfoNVX::initialize(const safe_VkObjectTableCreateI
 
 safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     viewportWScalingEnable(in_struct->viewportWScalingEnable),
     viewportCount(in_struct->viewportCount),
     pViewportWScalings(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewportWScalings) {
         pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
         memcpy ((void *)pViewportWScalings, (void *)in_struct->pViewportWScalings, sizeof(VkViewportWScalingNV)*in_struct->viewportCount);
@@ -16412,16 +18005,17 @@ safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalin
 }
 
 safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV() :
+    pNext(nullptr),
     pViewportWScalings(nullptr)
 {}
 
 safe_VkPipelineViewportWScalingStateCreateInfoNV::safe_VkPipelineViewportWScalingStateCreateInfoNV(const safe_VkPipelineViewportWScalingStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     viewportWScalingEnable = src.viewportWScalingEnable;
     viewportCount = src.viewportCount;
     pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewportWScalings) {
         pViewportWScalings = new VkViewportWScalingNV[src.viewportCount];
         memcpy ((void *)pViewportWScalings, (void *)src.pViewportWScalings, sizeof(VkViewportWScalingNV)*src.viewportCount);
@@ -16434,12 +18028,14 @@ safe_VkPipelineViewportWScalingStateCreateInfoNV& safe_VkPipelineViewportWScalin
 
     if (pViewportWScalings)
         delete[] pViewportWScalings;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     viewportWScalingEnable = src.viewportWScalingEnable;
     viewportCount = src.viewportCount;
     pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewportWScalings) {
         pViewportWScalings = new VkViewportWScalingNV[src.viewportCount];
         memcpy ((void *)pViewportWScalings, (void *)src.pViewportWScalings, sizeof(VkViewportWScalingNV)*src.viewportCount);
@@ -16452,15 +18048,17 @@ safe_VkPipelineViewportWScalingStateCreateInfoNV::~safe_VkPipelineViewportWScali
 {
     if (pViewportWScalings)
         delete[] pViewportWScalings;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const VkPipelineViewportWScalingStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     viewportWScalingEnable = in_struct->viewportWScalingEnable;
     viewportCount = in_struct->viewportCount;
     pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewportWScalings) {
         pViewportWScalings = new VkViewportWScalingNV[in_struct->viewportCount];
         memcpy ((void *)pViewportWScalings, (void *)in_struct->pViewportWScalings, sizeof(VkViewportWScalingNV)*in_struct->viewportCount);
@@ -16470,10 +18068,10 @@ void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const VkPipeli
 void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const safe_VkPipelineViewportWScalingStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     viewportWScalingEnable = src->viewportWScalingEnable;
     viewportCount = src->viewportCount;
     pViewportWScalings = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pViewportWScalings) {
         pViewportWScalings = new VkViewportWScalingNV[src->viewportCount];
         memcpy ((void *)pViewportWScalings, (void *)src->pViewportWScalings, sizeof(VkViewportWScalingNV)*src->viewportCount);
@@ -16482,7 +18080,6 @@ void safe_VkPipelineViewportWScalingStateCreateInfoNV::initialize(const safe_VkP
 
 safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const VkSurfaceCapabilities2EXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     minImageCount(in_struct->minImageCount),
     maxImageCount(in_struct->maxImageCount),
     currentExtent(in_struct->currentExtent),
@@ -16495,15 +18092,16 @@ safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const VkSurfaceCa
     supportedUsageFlags(in_struct->supportedUsageFlags),
     supportedSurfaceCounters(in_struct->supportedSurfaceCounters)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT()
+safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT() :
+    pNext(nullptr)
 {}
 
 safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const safe_VkSurfaceCapabilities2EXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     minImageCount = src.minImageCount;
     maxImageCount = src.maxImageCount;
     currentExtent = src.currentExtent;
@@ -16515,15 +18113,17 @@ safe_VkSurfaceCapabilities2EXT::safe_VkSurfaceCapabilities2EXT(const safe_VkSurf
     supportedCompositeAlpha = src.supportedCompositeAlpha;
     supportedUsageFlags = src.supportedUsageFlags;
     supportedSurfaceCounters = src.supportedSurfaceCounters;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSurfaceCapabilities2EXT& safe_VkSurfaceCapabilities2EXT::operator=(const safe_VkSurfaceCapabilities2EXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     minImageCount = src.minImageCount;
     maxImageCount = src.maxImageCount;
     currentExtent = src.currentExtent;
@@ -16535,18 +18135,20 @@ safe_VkSurfaceCapabilities2EXT& safe_VkSurfaceCapabilities2EXT::operator=(const
     supportedCompositeAlpha = src.supportedCompositeAlpha;
     supportedUsageFlags = src.supportedUsageFlags;
     supportedSurfaceCounters = src.supportedSurfaceCounters;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSurfaceCapabilities2EXT::~safe_VkSurfaceCapabilities2EXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSurfaceCapabilities2EXT::initialize(const VkSurfaceCapabilities2EXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     minImageCount = in_struct->minImageCount;
     maxImageCount = in_struct->maxImageCount;
     currentExtent = in_struct->currentExtent;
@@ -16558,12 +18160,12 @@ void safe_VkSurfaceCapabilities2EXT::initialize(const VkSurfaceCapabilities2EXT*
     supportedCompositeAlpha = in_struct->supportedCompositeAlpha;
     supportedUsageFlags = in_struct->supportedUsageFlags;
     supportedSurfaceCounters = in_struct->supportedSurfaceCounters;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSurfaceCapabilities2EXT::initialize(const safe_VkSurfaceCapabilities2EXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     minImageCount = src->minImageCount;
     maxImageCount = src->maxImageCount;
     currentExtent = src->currentExtent;
@@ -16575,202 +18177,223 @@ void safe_VkSurfaceCapabilities2EXT::initialize(const safe_VkSurfaceCapabilities
     supportedCompositeAlpha = src->supportedCompositeAlpha;
     supportedUsageFlags = src->supportedUsageFlags;
     supportedSurfaceCounters = src->supportedSurfaceCounters;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const VkDisplayPowerInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     powerState(in_struct->powerState)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT()
+safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayPowerInfoEXT::safe_VkDisplayPowerInfoEXT(const safe_VkDisplayPowerInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     powerState = src.powerState;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayPowerInfoEXT& safe_VkDisplayPowerInfoEXT::operator=(const safe_VkDisplayPowerInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     powerState = src.powerState;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayPowerInfoEXT::~safe_VkDisplayPowerInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayPowerInfoEXT::initialize(const VkDisplayPowerInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     powerState = in_struct->powerState;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayPowerInfoEXT::initialize(const safe_VkDisplayPowerInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     powerState = src->powerState;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const VkDeviceEventInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     deviceEvent(in_struct->deviceEvent)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT()
+safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceEventInfoEXT::safe_VkDeviceEventInfoEXT(const safe_VkDeviceEventInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     deviceEvent = src.deviceEvent;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceEventInfoEXT& safe_VkDeviceEventInfoEXT::operator=(const safe_VkDeviceEventInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     deviceEvent = src.deviceEvent;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceEventInfoEXT::~safe_VkDeviceEventInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceEventInfoEXT::initialize(const VkDeviceEventInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     deviceEvent = in_struct->deviceEvent;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceEventInfoEXT::initialize(const safe_VkDeviceEventInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     deviceEvent = src->deviceEvent;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const VkDisplayEventInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     displayEvent(in_struct->displayEvent)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT()
+safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayEventInfoEXT::safe_VkDisplayEventInfoEXT(const safe_VkDisplayEventInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     displayEvent = src.displayEvent;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayEventInfoEXT& safe_VkDisplayEventInfoEXT::operator=(const safe_VkDisplayEventInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     displayEvent = src.displayEvent;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayEventInfoEXT::~safe_VkDisplayEventInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayEventInfoEXT::initialize(const VkDisplayEventInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     displayEvent = in_struct->displayEvent;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayEventInfoEXT::initialize(const safe_VkDisplayEventInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     displayEvent = src->displayEvent;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const VkSwapchainCounterCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     surfaceCounters(in_struct->surfaceCounters)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT()
+safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkSwapchainCounterCreateInfoEXT::safe_VkSwapchainCounterCreateInfoEXT(const safe_VkSwapchainCounterCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     surfaceCounters = src.surfaceCounters;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSwapchainCounterCreateInfoEXT& safe_VkSwapchainCounterCreateInfoEXT::operator=(const safe_VkSwapchainCounterCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     surfaceCounters = src.surfaceCounters;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSwapchainCounterCreateInfoEXT::~safe_VkSwapchainCounterCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSwapchainCounterCreateInfoEXT::initialize(const VkSwapchainCounterCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     surfaceCounters = in_struct->surfaceCounters;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSwapchainCounterCreateInfoEXT::initialize(const safe_VkSwapchainCounterCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     surfaceCounters = src->surfaceCounters;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const VkPresentTimesInfoGOOGLE* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     swapchainCount(in_struct->swapchainCount),
     pTimes(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pTimes) {
         pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
         memcpy ((void *)pTimes, (void *)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE)*in_struct->swapchainCount);
@@ -16778,15 +18401,16 @@ safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const VkPresentTime
 }
 
 safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE() :
+    pNext(nullptr),
     pTimes(nullptr)
 {}
 
 safe_VkPresentTimesInfoGOOGLE::safe_VkPresentTimesInfoGOOGLE(const safe_VkPresentTimesInfoGOOGLE& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     swapchainCount = src.swapchainCount;
     pTimes = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pTimes) {
         pTimes = new VkPresentTimeGOOGLE[src.swapchainCount];
         memcpy ((void *)pTimes, (void *)src.pTimes, sizeof(VkPresentTimeGOOGLE)*src.swapchainCount);
@@ -16799,11 +18423,13 @@ safe_VkPresentTimesInfoGOOGLE& safe_VkPresentTimesInfoGOOGLE::operator=(const sa
 
     if (pTimes)
         delete[] pTimes;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     swapchainCount = src.swapchainCount;
     pTimes = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pTimes) {
         pTimes = new VkPresentTimeGOOGLE[src.swapchainCount];
         memcpy ((void *)pTimes, (void *)src.pTimes, sizeof(VkPresentTimeGOOGLE)*src.swapchainCount);
@@ -16816,14 +18442,16 @@ safe_VkPresentTimesInfoGOOGLE::~safe_VkPresentTimesInfoGOOGLE()
 {
     if (pTimes)
         delete[] pTimes;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPresentTimesInfoGOOGLE::initialize(const VkPresentTimesInfoGOOGLE* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     swapchainCount = in_struct->swapchainCount;
     pTimes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pTimes) {
         pTimes = new VkPresentTimeGOOGLE[in_struct->swapchainCount];
         memcpy ((void *)pTimes, (void *)in_struct->pTimes, sizeof(VkPresentTimeGOOGLE)*in_struct->swapchainCount);
@@ -16833,9 +18461,9 @@ void safe_VkPresentTimesInfoGOOGLE::initialize(const VkPresentTimesInfoGOOGLE* i
 void safe_VkPresentTimesInfoGOOGLE::initialize(const safe_VkPresentTimesInfoGOOGLE* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     swapchainCount = src->swapchainCount;
     pTimes = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pTimes) {
         pTimes = new VkPresentTimeGOOGLE[src->swapchainCount];
         memcpy ((void *)pTimes, (void *)src->pTimes, sizeof(VkPresentTimeGOOGLE)*src->swapchainCount);
@@ -16844,58 +18472,63 @@ void safe_VkPresentTimesInfoGOOGLE::initialize(const safe_VkPresentTimesInfoGOOG
 
 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     perViewPositionAllComponents(in_struct->perViewPositionAllComponents)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
+safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     perViewPositionAllComponents = src.perViewPositionAllComponents;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::operator=(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     perViewPositionAllComponents = src.perViewPositionAllComponents;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::~safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     perViewPositionAllComponents = in_struct->perViewPositionAllComponents;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX::initialize(const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     perViewPositionAllComponents = src->perViewPositionAllComponents;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     viewportCount(in_struct->viewportCount),
     pViewportSwizzles(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewportSwizzles) {
         pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
         memcpy ((void *)pViewportSwizzles, (void *)in_struct->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*in_struct->viewportCount);
@@ -16903,16 +18536,17 @@ safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleS
 }
 
 safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV() :
+    pNext(nullptr),
     pViewportSwizzles(nullptr)
 {}
 
 safe_VkPipelineViewportSwizzleStateCreateInfoNV::safe_VkPipelineViewportSwizzleStateCreateInfoNV(const safe_VkPipelineViewportSwizzleStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     viewportCount = src.viewportCount;
     pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewportSwizzles) {
         pViewportSwizzles = new VkViewportSwizzleNV[src.viewportCount];
         memcpy ((void *)pViewportSwizzles, (void *)src.pViewportSwizzles, sizeof(VkViewportSwizzleNV)*src.viewportCount);
@@ -16925,12 +18559,14 @@ safe_VkPipelineViewportSwizzleStateCreateInfoNV& safe_VkPipelineViewportSwizzleS
 
     if (pViewportSwizzles)
         delete[] pViewportSwizzles;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     viewportCount = src.viewportCount;
     pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pViewportSwizzles) {
         pViewportSwizzles = new VkViewportSwizzleNV[src.viewportCount];
         memcpy ((void *)pViewportSwizzles, (void *)src.pViewportSwizzles, sizeof(VkViewportSwizzleNV)*src.viewportCount);
@@ -16943,15 +18579,17 @@ safe_VkPipelineViewportSwizzleStateCreateInfoNV::~safe_VkPipelineViewportSwizzle
 {
     if (pViewportSwizzles)
         delete[] pViewportSwizzles;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const VkPipelineViewportSwizzleStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     viewportCount = in_struct->viewportCount;
     pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pViewportSwizzles) {
         pViewportSwizzles = new VkViewportSwizzleNV[in_struct->viewportCount];
         memcpy ((void *)pViewportSwizzles, (void *)in_struct->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*in_struct->viewportCount);
@@ -16961,10 +18599,10 @@ void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const VkPipelin
 void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const safe_VkPipelineViewportSwizzleStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     viewportCount = src->viewportCount;
     pViewportSwizzles = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pViewportSwizzles) {
         pViewportSwizzles = new VkViewportSwizzleNV[src->viewportCount];
         memcpy ((void *)pViewportSwizzles, (void *)src->pViewportSwizzles, sizeof(VkViewportSwizzleNV)*src->viewportCount);
@@ -16973,59 +18611,64 @@ void safe_VkPipelineViewportSwizzleStateCreateInfoNV::initialize(const safe_VkPi
 
 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxDiscardRectangles(in_struct->maxDiscardRectangles)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT()
+safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxDiscardRectangles = src.maxDiscardRectangles;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::operator=(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxDiscardRectangles = src.maxDiscardRectangles;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::~safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const VkPhysicalDeviceDiscardRectanglePropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxDiscardRectangles = in_struct->maxDiscardRectangles;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT::initialize(const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxDiscardRectangles = src->maxDiscardRectangles;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     discardRectangleMode(in_struct->discardRectangleMode),
     discardRectangleCount(in_struct->discardRectangleCount),
     pDiscardRectangles(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDiscardRectangles) {
         pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
         memcpy ((void *)pDiscardRectangles, (void *)in_struct->pDiscardRectangles, sizeof(VkRect2D)*in_struct->discardRectangleCount);
@@ -17033,17 +18676,18 @@ safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectang
 }
 
 safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT() :
+    pNext(nullptr),
     pDiscardRectangles(nullptr)
 {}
 
 safe_VkPipelineDiscardRectangleStateCreateInfoEXT::safe_VkPipelineDiscardRectangleStateCreateInfoEXT(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     discardRectangleMode = src.discardRectangleMode;
     discardRectangleCount = src.discardRectangleCount;
     pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDiscardRectangles) {
         pDiscardRectangles = new VkRect2D[src.discardRectangleCount];
         memcpy ((void *)pDiscardRectangles, (void *)src.pDiscardRectangles, sizeof(VkRect2D)*src.discardRectangleCount);
@@ -17056,13 +18700,15 @@ safe_VkPipelineDiscardRectangleStateCreateInfoEXT& safe_VkPipelineDiscardRectang
 
     if (pDiscardRectangles)
         delete[] pDiscardRectangles;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     discardRectangleMode = src.discardRectangleMode;
     discardRectangleCount = src.discardRectangleCount;
     pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDiscardRectangles) {
         pDiscardRectangles = new VkRect2D[src.discardRectangleCount];
         memcpy ((void *)pDiscardRectangles, (void *)src.pDiscardRectangles, sizeof(VkRect2D)*src.discardRectangleCount);
@@ -17075,16 +18721,18 @@ safe_VkPipelineDiscardRectangleStateCreateInfoEXT::~safe_VkPipelineDiscardRectan
 {
     if (pDiscardRectangles)
         delete[] pDiscardRectangles;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const VkPipelineDiscardRectangleStateCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     discardRectangleMode = in_struct->discardRectangleMode;
     discardRectangleCount = in_struct->discardRectangleCount;
     pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDiscardRectangles) {
         pDiscardRectangles = new VkRect2D[in_struct->discardRectangleCount];
         memcpy ((void *)pDiscardRectangles, (void *)in_struct->pDiscardRectangles, sizeof(VkRect2D)*in_struct->discardRectangleCount);
@@ -17094,11 +18742,11 @@ void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const VkPipel
 void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const safe_VkPipelineDiscardRectangleStateCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     discardRectangleMode = src->discardRectangleMode;
     discardRectangleCount = src->discardRectangleCount;
     pDiscardRectangles = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDiscardRectangles) {
         pDiscardRectangles = new VkRect2D[src->discardRectangleCount];
         memcpy ((void *)pDiscardRectangles, (void *)src->pDiscardRectangles, sizeof(VkRect2D)*src->discardRectangleCount);
@@ -17107,7 +18755,6 @@ void safe_VkPipelineDiscardRectangleStateCreateInfoEXT::initialize(const safe_Vk
 
 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     primitiveOverestimationSize(in_struct->primitiveOverestimationSize),
     maxExtraPrimitiveOverestimationSize(in_struct->maxExtraPrimitiveOverestimationSize),
     extraPrimitiveOverestimationSizeGranularity(in_struct->extraPrimitiveOverestimationSizeGranularity),
@@ -17118,15 +18765,16 @@ safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDevi
     fullyCoveredFragmentShaderInputVariable(in_struct->fullyCoveredFragmentShaderInputVariable),
     conservativeRasterizationPostDepthCoverage(in_struct->conservativeRasterizationPostDepthCoverage)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT()
+safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     primitiveOverestimationSize = src.primitiveOverestimationSize;
     maxExtraPrimitiveOverestimationSize = src.maxExtraPrimitiveOverestimationSize;
     extraPrimitiveOverestimationSizeGranularity = src.extraPrimitiveOverestimationSizeGranularity;
@@ -17136,15 +18784,17 @@ safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::safe_VkPhysicalDevi
     degenerateLinesRasterized = src.degenerateLinesRasterized;
     fullyCoveredFragmentShaderInputVariable = src.fullyCoveredFragmentShaderInputVariable;
     conservativeRasterizationPostDepthCoverage = src.conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::operator=(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     primitiveOverestimationSize = src.primitiveOverestimationSize;
     maxExtraPrimitiveOverestimationSize = src.maxExtraPrimitiveOverestimationSize;
     extraPrimitiveOverestimationSizeGranularity = src.extraPrimitiveOverestimationSizeGranularity;
@@ -17154,18 +18804,20 @@ safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT& safe_VkPhysicalDevi
     degenerateLinesRasterized = src.degenerateLinesRasterized;
     fullyCoveredFragmentShaderInputVariable = src.fullyCoveredFragmentShaderInputVariable;
     conservativeRasterizationPostDepthCoverage = src.conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::~safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     primitiveOverestimationSize = in_struct->primitiveOverestimationSize;
     maxExtraPrimitiveOverestimationSize = in_struct->maxExtraPrimitiveOverestimationSize;
     extraPrimitiveOverestimationSizeGranularity = in_struct->extraPrimitiveOverestimationSizeGranularity;
@@ -17175,12 +18827,12 @@ void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(con
     degenerateLinesRasterized = in_struct->degenerateLinesRasterized;
     fullyCoveredFragmentShaderInputVariable = in_struct->fullyCoveredFragmentShaderInputVariable;
     conservativeRasterizationPostDepthCoverage = in_struct->conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     primitiveOverestimationSize = src->primitiveOverestimationSize;
     maxExtraPrimitiveOverestimationSize = src->maxExtraPrimitiveOverestimationSize;
     extraPrimitiveOverestimationSizeGranularity = src->extraPrimitiveOverestimationSizeGranularity;
@@ -17190,167 +18842,182 @@ void safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT::initialize(con
     degenerateLinesRasterized = src->degenerateLinesRasterized;
     fullyCoveredFragmentShaderInputVariable = src->fullyCoveredFragmentShaderInputVariable;
     conservativeRasterizationPostDepthCoverage = src->conservativeRasterizationPostDepthCoverage;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     conservativeRasterizationMode(in_struct->conservativeRasterizationMode),
     extraPrimitiveOverestimationSize(in_struct->extraPrimitiveOverestimationSize)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT()
+safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     conservativeRasterizationMode = src.conservativeRasterizationMode;
     extraPrimitiveOverestimationSize = src.extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::operator=(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     conservativeRasterizationMode = src.conservativeRasterizationMode;
     extraPrimitiveOverestimationSize = src.extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::~safe_VkPipelineRasterizationConservativeStateCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize(const VkPipelineRasterizationConservativeStateCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     conservativeRasterizationMode = in_struct->conservativeRasterizationMode;
     extraPrimitiveOverestimationSize = in_struct->extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineRasterizationConservativeStateCreateInfoEXT::initialize(const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     conservativeRasterizationMode = src->conservativeRasterizationMode;
     extraPrimitiveOverestimationSize = src->extraPrimitiveOverestimationSize;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     depthClipEnable(in_struct->depthClipEnable)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT()
+safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     depthClipEnable = src.depthClipEnable;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::operator=(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     depthClipEnable = src.depthClipEnable;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::~safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const VkPhysicalDeviceDepthClipEnableFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     depthClipEnable = in_struct->depthClipEnable;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT::initialize(const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     depthClipEnable = src->depthClipEnable;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     depthClipEnable(in_struct->depthClipEnable)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT()
+safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     depthClipEnable = src.depthClipEnable;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::operator=(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     depthClipEnable = src.depthClipEnable;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::~safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize(const VkPipelineRasterizationDepthClipStateCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     depthClipEnable = in_struct->depthClipEnable;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT::initialize(const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     depthClipEnable = src->depthClipEnable;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     displayPrimaryRed(in_struct->displayPrimaryRed),
     displayPrimaryGreen(in_struct->displayPrimaryGreen),
     displayPrimaryBlue(in_struct->displayPrimaryBlue),
@@ -17360,15 +19027,16 @@ safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const VkHdrMetadataEXT* in_struct)
     maxContentLightLevel(in_struct->maxContentLightLevel),
     maxFrameAverageLightLevel(in_struct->maxFrameAverageLightLevel)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT()
+safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     displayPrimaryRed = src.displayPrimaryRed;
     displayPrimaryGreen = src.displayPrimaryGreen;
     displayPrimaryBlue = src.displayPrimaryBlue;
@@ -17377,15 +19045,17 @@ safe_VkHdrMetadataEXT::safe_VkHdrMetadataEXT(const safe_VkHdrMetadataEXT& src)
     minLuminance = src.minLuminance;
     maxContentLightLevel = src.maxContentLightLevel;
     maxFrameAverageLightLevel = src.maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkHdrMetadataEXT& safe_VkHdrMetadataEXT::operator=(const safe_VkHdrMetadataEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     displayPrimaryRed = src.displayPrimaryRed;
     displayPrimaryGreen = src.displayPrimaryGreen;
     displayPrimaryBlue = src.displayPrimaryBlue;
@@ -17394,18 +19064,20 @@ safe_VkHdrMetadataEXT& safe_VkHdrMetadataEXT::operator=(const safe_VkHdrMetadata
     minLuminance = src.minLuminance;
     maxContentLightLevel = src.maxContentLightLevel;
     maxFrameAverageLightLevel = src.maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkHdrMetadataEXT::~safe_VkHdrMetadataEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkHdrMetadataEXT::initialize(const VkHdrMetadataEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     displayPrimaryRed = in_struct->displayPrimaryRed;
     displayPrimaryGreen = in_struct->displayPrimaryGreen;
     displayPrimaryBlue = in_struct->displayPrimaryBlue;
@@ -17414,12 +19086,12 @@ void safe_VkHdrMetadataEXT::initialize(const VkHdrMetadataEXT* in_struct)
     minLuminance = in_struct->minLuminance;
     maxContentLightLevel = in_struct->maxContentLightLevel;
     maxFrameAverageLightLevel = in_struct->maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkHdrMetadataEXT::initialize(const safe_VkHdrMetadataEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     displayPrimaryRed = src->displayPrimaryRed;
     displayPrimaryGreen = src->displayPrimaryGreen;
     displayPrimaryBlue = src->displayPrimaryBlue;
@@ -17428,60 +19100,67 @@ void safe_VkHdrMetadataEXT::initialize(const safe_VkHdrMetadataEXT* src)
     minLuminance = src->minLuminance;
     maxContentLightLevel = src->maxContentLightLevel;
     maxFrameAverageLightLevel = src->maxFrameAverageLightLevel;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_IOS_MVK
 
 
 safe_VkIOSSurfaceCreateInfoMVK::safe_VkIOSSurfaceCreateInfoMVK(const VkIOSSurfaceCreateInfoMVK* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     pView(in_struct->pView)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkIOSSurfaceCreateInfoMVK::safe_VkIOSSurfaceCreateInfoMVK()
+safe_VkIOSSurfaceCreateInfoMVK::safe_VkIOSSurfaceCreateInfoMVK() :
+    pNext(nullptr),
+    pView(nullptr)
 {}
 
 safe_VkIOSSurfaceCreateInfoMVK::safe_VkIOSSurfaceCreateInfoMVK(const safe_VkIOSSurfaceCreateInfoMVK& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pView = src.pView;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkIOSSurfaceCreateInfoMVK& safe_VkIOSSurfaceCreateInfoMVK::operator=(const safe_VkIOSSurfaceCreateInfoMVK& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pView = src.pView;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkIOSSurfaceCreateInfoMVK::~safe_VkIOSSurfaceCreateInfoMVK()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkIOSSurfaceCreateInfoMVK::initialize(const VkIOSSurfaceCreateInfoMVK* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     pView = in_struct->pView;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkIOSSurfaceCreateInfoMVK::initialize(const safe_VkIOSSurfaceCreateInfoMVK* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     pView = src->pView;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_IOS_MVK
 
@@ -17490,201 +19169,223 @@ void safe_VkIOSSurfaceCreateInfoMVK::initialize(const safe_VkIOSSurfaceCreateInf
 
 safe_VkMacOSSurfaceCreateInfoMVK::safe_VkMacOSSurfaceCreateInfoMVK(const VkMacOSSurfaceCreateInfoMVK* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     pView(in_struct->pView)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMacOSSurfaceCreateInfoMVK::safe_VkMacOSSurfaceCreateInfoMVK()
+safe_VkMacOSSurfaceCreateInfoMVK::safe_VkMacOSSurfaceCreateInfoMVK() :
+    pNext(nullptr),
+    pView(nullptr)
 {}
 
 safe_VkMacOSSurfaceCreateInfoMVK::safe_VkMacOSSurfaceCreateInfoMVK(const safe_VkMacOSSurfaceCreateInfoMVK& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pView = src.pView;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMacOSSurfaceCreateInfoMVK& safe_VkMacOSSurfaceCreateInfoMVK::operator=(const safe_VkMacOSSurfaceCreateInfoMVK& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pView = src.pView;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMacOSSurfaceCreateInfoMVK::~safe_VkMacOSSurfaceCreateInfoMVK()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMacOSSurfaceCreateInfoMVK::initialize(const VkMacOSSurfaceCreateInfoMVK* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     pView = in_struct->pView;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMacOSSurfaceCreateInfoMVK::initialize(const safe_VkMacOSSurfaceCreateInfoMVK* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     pView = src->pView;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_MACOS_MVK
 
 
 safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const VkDebugUtilsObjectNameInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     objectType(in_struct->objectType),
-    objectHandle(in_struct->objectHandle),
-    pObjectName(in_struct->pObjectName)
+    objectHandle(in_struct->objectHandle)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
 }
 
-safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT()
+safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT() :
+    pNext(nullptr),
+    pObjectName(nullptr)
 {}
 
 safe_VkDebugUtilsObjectNameInfoEXT::safe_VkDebugUtilsObjectNameInfoEXT(const safe_VkDebugUtilsObjectNameInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     objectHandle = src.objectHandle;
-    pObjectName = src.pObjectName;
+    pNext = SafePnextCopy(src.pNext);
+    pObjectName = SafeStringCopy(src.pObjectName);
 }
 
 safe_VkDebugUtilsObjectNameInfoEXT& safe_VkDebugUtilsObjectNameInfoEXT::operator=(const safe_VkDebugUtilsObjectNameInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pObjectName) delete [] pObjectName;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     objectHandle = src.objectHandle;
-    pObjectName = src.pObjectName;
+    pNext = SafePnextCopy(src.pNext);
+    pObjectName = SafeStringCopy(src.pObjectName);
 
     return *this;
 }
 
 safe_VkDebugUtilsObjectNameInfoEXT::~safe_VkDebugUtilsObjectNameInfoEXT()
 {
+    if (pObjectName) delete [] pObjectName;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const VkDebugUtilsObjectNameInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     objectType = in_struct->objectType;
     objectHandle = in_struct->objectHandle;
-    pObjectName = in_struct->pObjectName;
+    pNext = SafePnextCopy(in_struct->pNext);
+    pObjectName = SafeStringCopy(in_struct->pObjectName);
 }
 
 void safe_VkDebugUtilsObjectNameInfoEXT::initialize(const safe_VkDebugUtilsObjectNameInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     objectType = src->objectType;
     objectHandle = src->objectHandle;
-    pObjectName = src->pObjectName;
+    pNext = SafePnextCopy(src->pNext);
+    pObjectName = SafeStringCopy(src->pObjectName);
 }
 
 safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const VkDebugUtilsObjectTagInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     objectType(in_struct->objectType),
     objectHandle(in_struct->objectHandle),
     tagName(in_struct->tagName),
     tagSize(in_struct->tagSize),
     pTag(in_struct->pTag)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT()
+safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT() :
+    pNext(nullptr),
+    pTag(nullptr)
 {}
 
 safe_VkDebugUtilsObjectTagInfoEXT::safe_VkDebugUtilsObjectTagInfoEXT(const safe_VkDebugUtilsObjectTagInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     objectHandle = src.objectHandle;
     tagName = src.tagName;
     tagSize = src.tagSize;
     pTag = src.pTag;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDebugUtilsObjectTagInfoEXT& safe_VkDebugUtilsObjectTagInfoEXT::operator=(const safe_VkDebugUtilsObjectTagInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     objectType = src.objectType;
     objectHandle = src.objectHandle;
     tagName = src.tagName;
     tagSize = src.tagSize;
     pTag = src.pTag;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDebugUtilsObjectTagInfoEXT::~safe_VkDebugUtilsObjectTagInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const VkDebugUtilsObjectTagInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     objectType = in_struct->objectType;
     objectHandle = in_struct->objectHandle;
     tagName = in_struct->tagName;
     tagSize = in_struct->tagSize;
     pTag = in_struct->pTag;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDebugUtilsObjectTagInfoEXT::initialize(const safe_VkDebugUtilsObjectTagInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     objectType = src->objectType;
     objectHandle = src->objectHandle;
     tagName = src->tagName;
     tagSize = src->tagSize;
     pTag = src->pTag;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const VkDebugUtilsLabelEXT* in_struct) :
-    sType(in_struct->sType),
-    pNext(in_struct->pNext),
-    pLabelName(in_struct->pLabelName)
+    sType(in_struct->sType)
 {
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pLabelName = SafeStringCopy(in_struct->pLabelName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = in_struct->color[i];
     }
 }
 
-safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT()
+safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT() :
+    pNext(nullptr),
+    pLabelName(nullptr)
 {}
 
 safe_VkDebugUtilsLabelEXT::safe_VkDebugUtilsLabelEXT(const safe_VkDebugUtilsLabelEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
-    pLabelName = src.pLabelName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    pLabelName = SafeStringCopy(src.pLabelName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = src.color[i];
     }
 }
@@ -17693,11 +19394,14 @@ safe_VkDebugUtilsLabelEXT& safe_VkDebugUtilsLabelEXT::operator=(const safe_VkDeb
 {
     if (&src == this) return *this;
 
+    if (pLabelName) delete [] pLabelName;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
-    pLabelName = src.pLabelName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    pLabelName = SafeStringCopy(src.pLabelName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = src.color[i];
     }
 
@@ -17706,14 +19410,17 @@ safe_VkDebugUtilsLabelEXT& safe_VkDebugUtilsLabelEXT::operator=(const safe_VkDeb
 
 safe_VkDebugUtilsLabelEXT::~safe_VkDebugUtilsLabelEXT()
 {
+    if (pLabelName) delete [] pLabelName;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugUtilsLabelEXT::initialize(const VkDebugUtilsLabelEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
-    pLabelName = in_struct->pLabelName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pLabelName = SafeStringCopy(in_struct->pLabelName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = in_struct->color[i];
     }
 }
@@ -17721,20 +19428,17 @@ void safe_VkDebugUtilsLabelEXT::initialize(const VkDebugUtilsLabelEXT* in_struct
 void safe_VkDebugUtilsLabelEXT::initialize(const safe_VkDebugUtilsLabelEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
-    pLabelName = src->pLabelName;
-    for (uint32_t i=0; i<4; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    pLabelName = SafeStringCopy(src->pLabelName);
+    for (uint32_t i = 0; i < 4; ++i) {
         color[i] = src->color[i];
     }
 }
 
 safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT(const VkDebugUtilsMessengerCallbackDataEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
-    pMessageIdName(in_struct->pMessageIdName),
     messageIdNumber(in_struct->messageIdNumber),
-    pMessage(in_struct->pMessage),
     queueLabelCount(in_struct->queueLabelCount),
     pQueueLabels(nullptr),
     cmdBufLabelCount(in_struct->cmdBufLabelCount),
@@ -17742,27 +19446,33 @@ safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDat
     objectCount(in_struct->objectCount),
     pObjects(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
+    pMessageIdName = SafeStringCopy(in_struct->pMessageIdName);
+    pMessage = SafeStringCopy(in_struct->pMessage);
     if (queueLabelCount && in_struct->pQueueLabels) {
         pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
-        for (uint32_t i=0; i<queueLabelCount; ++i) {
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
             pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
         }
     }
     if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
         pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
-        for (uint32_t i=0; i<cmdBufLabelCount; ++i) {
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
             pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
         }
     }
     if (objectCount && in_struct->pObjects) {
         pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
-        for (uint32_t i=0; i<objectCount; ++i) {
+        for (uint32_t i = 0; i < objectCount; ++i) {
             pObjects[i].initialize(&in_struct->pObjects[i]);
         }
     }
 }
 
 safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT() :
+    pNext(nullptr),
+    pMessageIdName(nullptr),
+    pMessage(nullptr),
     pQueueLabels(nullptr),
     pCmdBufLabels(nullptr),
     pObjects(nullptr)
@@ -17771,32 +19481,32 @@ safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDat
 safe_VkDebugUtilsMessengerCallbackDataEXT::safe_VkDebugUtilsMessengerCallbackDataEXT(const safe_VkDebugUtilsMessengerCallbackDataEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
-    pMessageIdName = src.pMessageIdName;
     messageIdNumber = src.messageIdNumber;
-    pMessage = src.pMessage;
     queueLabelCount = src.queueLabelCount;
     pQueueLabels = nullptr;
     cmdBufLabelCount = src.cmdBufLabelCount;
     pCmdBufLabels = nullptr;
     objectCount = src.objectCount;
     pObjects = nullptr;
+    pNext = SafePnextCopy(src.pNext);
+    pMessageIdName = SafeStringCopy(src.pMessageIdName);
+    pMessage = SafeStringCopy(src.pMessage);
     if (queueLabelCount && src.pQueueLabels) {
         pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
-        for (uint32_t i=0; i<queueLabelCount; ++i) {
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
             pQueueLabels[i].initialize(&src.pQueueLabels[i]);
         }
     }
     if (cmdBufLabelCount && src.pCmdBufLabels) {
         pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
-        for (uint32_t i=0; i<cmdBufLabelCount; ++i) {
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
             pCmdBufLabels[i].initialize(&src.pCmdBufLabels[i]);
         }
     }
     if (objectCount && src.pObjects) {
         pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
-        for (uint32_t i=0; i<objectCount; ++i) {
+        for (uint32_t i = 0; i < objectCount; ++i) {
             pObjects[i].initialize(&src.pObjects[i]);
         }
     }
@@ -17806,40 +19516,44 @@ safe_VkDebugUtilsMessengerCallbackDataEXT& safe_VkDebugUtilsMessengerCallbackDat
 {
     if (&src == this) return *this;
 
+    if (pMessageIdName) delete [] pMessageIdName;
+    if (pMessage) delete [] pMessage;
     if (pQueueLabels)
         delete[] pQueueLabels;
     if (pCmdBufLabels)
         delete[] pCmdBufLabels;
     if (pObjects)
         delete[] pObjects;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
-    pMessageIdName = src.pMessageIdName;
     messageIdNumber = src.messageIdNumber;
-    pMessage = src.pMessage;
     queueLabelCount = src.queueLabelCount;
     pQueueLabels = nullptr;
     cmdBufLabelCount = src.cmdBufLabelCount;
     pCmdBufLabels = nullptr;
     objectCount = src.objectCount;
     pObjects = nullptr;
+    pNext = SafePnextCopy(src.pNext);
+    pMessageIdName = SafeStringCopy(src.pMessageIdName);
+    pMessage = SafeStringCopy(src.pMessage);
     if (queueLabelCount && src.pQueueLabels) {
         pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
-        for (uint32_t i=0; i<queueLabelCount; ++i) {
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
             pQueueLabels[i].initialize(&src.pQueueLabels[i]);
         }
     }
     if (cmdBufLabelCount && src.pCmdBufLabels) {
         pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
-        for (uint32_t i=0; i<cmdBufLabelCount; ++i) {
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
             pCmdBufLabels[i].initialize(&src.pCmdBufLabels[i]);
         }
     }
     if (objectCount && src.pObjects) {
         pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
-        for (uint32_t i=0; i<objectCount; ++i) {
+        for (uint32_t i = 0; i < objectCount; ++i) {
             pObjects[i].initialize(&src.pObjects[i]);
         }
     }
@@ -17849,43 +19563,47 @@ safe_VkDebugUtilsMessengerCallbackDataEXT& safe_VkDebugUtilsMessengerCallbackDat
 
 safe_VkDebugUtilsMessengerCallbackDataEXT::~safe_VkDebugUtilsMessengerCallbackDataEXT()
 {
+    if (pMessageIdName) delete [] pMessageIdName;
+    if (pMessage) delete [] pMessage;
     if (pQueueLabels)
         delete[] pQueueLabels;
     if (pCmdBufLabels)
         delete[] pCmdBufLabels;
     if (pObjects)
         delete[] pObjects;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const VkDebugUtilsMessengerCallbackDataEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
-    pMessageIdName = in_struct->pMessageIdName;
     messageIdNumber = in_struct->messageIdNumber;
-    pMessage = in_struct->pMessage;
     queueLabelCount = in_struct->queueLabelCount;
     pQueueLabels = nullptr;
     cmdBufLabelCount = in_struct->cmdBufLabelCount;
     pCmdBufLabels = nullptr;
     objectCount = in_struct->objectCount;
     pObjects = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
+    pMessageIdName = SafeStringCopy(in_struct->pMessageIdName);
+    pMessage = SafeStringCopy(in_struct->pMessage);
     if (queueLabelCount && in_struct->pQueueLabels) {
         pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
-        for (uint32_t i=0; i<queueLabelCount; ++i) {
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
             pQueueLabels[i].initialize(&in_struct->pQueueLabels[i]);
         }
     }
     if (cmdBufLabelCount && in_struct->pCmdBufLabels) {
         pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
-        for (uint32_t i=0; i<cmdBufLabelCount; ++i) {
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
             pCmdBufLabels[i].initialize(&in_struct->pCmdBufLabels[i]);
         }
     }
     if (objectCount && in_struct->pObjects) {
         pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
-        for (uint32_t i=0; i<objectCount; ++i) {
+        for (uint32_t i = 0; i < objectCount; ++i) {
             pObjects[i].initialize(&in_struct->pObjects[i]);
         }
     }
@@ -17894,32 +19612,32 @@ void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const VkDebugUtilsMes
 void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const safe_VkDebugUtilsMessengerCallbackDataEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
-    pMessageIdName = src->pMessageIdName;
     messageIdNumber = src->messageIdNumber;
-    pMessage = src->pMessage;
     queueLabelCount = src->queueLabelCount;
     pQueueLabels = nullptr;
     cmdBufLabelCount = src->cmdBufLabelCount;
     pCmdBufLabels = nullptr;
     objectCount = src->objectCount;
     pObjects = nullptr;
+    pNext = SafePnextCopy(src->pNext);
+    pMessageIdName = SafeStringCopy(src->pMessageIdName);
+    pMessage = SafeStringCopy(src->pMessage);
     if (queueLabelCount && src->pQueueLabels) {
         pQueueLabels = new safe_VkDebugUtilsLabelEXT[queueLabelCount];
-        for (uint32_t i=0; i<queueLabelCount; ++i) {
+        for (uint32_t i = 0; i < queueLabelCount; ++i) {
             pQueueLabels[i].initialize(&src->pQueueLabels[i]);
         }
     }
     if (cmdBufLabelCount && src->pCmdBufLabels) {
         pCmdBufLabels = new safe_VkDebugUtilsLabelEXT[cmdBufLabelCount];
-        for (uint32_t i=0; i<cmdBufLabelCount; ++i) {
+        for (uint32_t i = 0; i < cmdBufLabelCount; ++i) {
             pCmdBufLabels[i].initialize(&src->pCmdBufLabels[i]);
         }
     }
     if (objectCount && src->pObjects) {
         pObjects = new safe_VkDebugUtilsObjectNameInfoEXT[objectCount];
-        for (uint32_t i=0; i<objectCount; ++i) {
+        for (uint32_t i = 0; i < objectCount; ++i) {
             pObjects[i].initialize(&src->pObjects[i]);
         }
     }
@@ -17927,118 +19645,129 @@ void safe_VkDebugUtilsMessengerCallbackDataEXT::initialize(const safe_VkDebugUti
 
 safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT(const VkDebugUtilsMessengerCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     messageSeverity(in_struct->messageSeverity),
     messageType(in_struct->messageType),
     pfnUserCallback(in_struct->pfnUserCallback),
     pUserData(in_struct->pUserData)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT()
+safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT() :
+    pNext(nullptr),
+    pUserData(nullptr)
 {}
 
 safe_VkDebugUtilsMessengerCreateInfoEXT::safe_VkDebugUtilsMessengerCreateInfoEXT(const safe_VkDebugUtilsMessengerCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     messageSeverity = src.messageSeverity;
     messageType = src.messageType;
     pfnUserCallback = src.pfnUserCallback;
     pUserData = src.pUserData;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDebugUtilsMessengerCreateInfoEXT& safe_VkDebugUtilsMessengerCreateInfoEXT::operator=(const safe_VkDebugUtilsMessengerCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     messageSeverity = src.messageSeverity;
     messageType = src.messageType;
     pfnUserCallback = src.pfnUserCallback;
     pUserData = src.pUserData;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDebugUtilsMessengerCreateInfoEXT::~safe_VkDebugUtilsMessengerCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const VkDebugUtilsMessengerCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     messageSeverity = in_struct->messageSeverity;
     messageType = in_struct->messageType;
     pfnUserCallback = in_struct->pfnUserCallback;
     pUserData = in_struct->pUserData;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDebugUtilsMessengerCreateInfoEXT::initialize(const safe_VkDebugUtilsMessengerCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     messageSeverity = src->messageSeverity;
     messageType = src->messageType;
     pfnUserCallback = src->pfnUserCallback;
     pUserData = src->pUserData;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 
 
 safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID(const VkAndroidHardwareBufferUsageANDROID* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     androidHardwareBufferUsage(in_struct->androidHardwareBufferUsage)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID()
+safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID() :
+    pNext(nullptr)
 {}
 
 safe_VkAndroidHardwareBufferUsageANDROID::safe_VkAndroidHardwareBufferUsageANDROID(const safe_VkAndroidHardwareBufferUsageANDROID& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     androidHardwareBufferUsage = src.androidHardwareBufferUsage;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAndroidHardwareBufferUsageANDROID& safe_VkAndroidHardwareBufferUsageANDROID::operator=(const safe_VkAndroidHardwareBufferUsageANDROID& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     androidHardwareBufferUsage = src.androidHardwareBufferUsage;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAndroidHardwareBufferUsageANDROID::~safe_VkAndroidHardwareBufferUsageANDROID()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const VkAndroidHardwareBufferUsageANDROID* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     androidHardwareBufferUsage = in_struct->androidHardwareBufferUsage;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const safe_VkAndroidHardwareBufferUsageANDROID* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     androidHardwareBufferUsage = src->androidHardwareBufferUsage;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
@@ -18047,54 +19776,59 @@ void safe_VkAndroidHardwareBufferUsageANDROID::initialize(const safe_VkAndroidHa
 
 safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID(const VkAndroidHardwareBufferPropertiesANDROID* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     allocationSize(in_struct->allocationSize),
     memoryTypeBits(in_struct->memoryTypeBits)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID()
+safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID() :
+    pNext(nullptr)
 {}
 
 safe_VkAndroidHardwareBufferPropertiesANDROID::safe_VkAndroidHardwareBufferPropertiesANDROID(const safe_VkAndroidHardwareBufferPropertiesANDROID& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     allocationSize = src.allocationSize;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAndroidHardwareBufferPropertiesANDROID& safe_VkAndroidHardwareBufferPropertiesANDROID::operator=(const safe_VkAndroidHardwareBufferPropertiesANDROID& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     allocationSize = src.allocationSize;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAndroidHardwareBufferPropertiesANDROID::~safe_VkAndroidHardwareBufferPropertiesANDROID()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const VkAndroidHardwareBufferPropertiesANDROID* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     allocationSize = in_struct->allocationSize;
     memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const safe_VkAndroidHardwareBufferPropertiesANDROID* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     allocationSize = src->allocationSize;
     memoryTypeBits = src->memoryTypeBits;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
@@ -18103,7 +19837,6 @@ void safe_VkAndroidHardwareBufferPropertiesANDROID::initialize(const safe_VkAndr
 
 safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     format(in_struct->format),
     externalFormat(in_struct->externalFormat),
     formatFeatures(in_struct->formatFeatures),
@@ -18113,15 +19846,16 @@ safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBuffe
     suggestedXChromaOffset(in_struct->suggestedXChromaOffset),
     suggestedYChromaOffset(in_struct->suggestedYChromaOffset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID()
+safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID() :
+    pNext(nullptr)
 {}
 
 safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBufferFormatPropertiesANDROID(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     externalFormat = src.externalFormat;
     formatFeatures = src.formatFeatures;
@@ -18130,15 +19864,17 @@ safe_VkAndroidHardwareBufferFormatPropertiesANDROID::safe_VkAndroidHardwareBuffe
     suggestedYcbcrRange = src.suggestedYcbcrRange;
     suggestedXChromaOffset = src.suggestedXChromaOffset;
     suggestedYChromaOffset = src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAndroidHardwareBufferFormatPropertiesANDROID& safe_VkAndroidHardwareBufferFormatPropertiesANDROID::operator=(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     format = src.format;
     externalFormat = src.externalFormat;
     formatFeatures = src.formatFeatures;
@@ -18147,18 +19883,20 @@ safe_VkAndroidHardwareBufferFormatPropertiesANDROID& safe_VkAndroidHardwareBuffe
     suggestedYcbcrRange = src.suggestedYcbcrRange;
     suggestedXChromaOffset = src.suggestedXChromaOffset;
     suggestedYChromaOffset = src.suggestedYChromaOffset;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAndroidHardwareBufferFormatPropertiesANDROID::~safe_VkAndroidHardwareBufferFormatPropertiesANDROID()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(const VkAndroidHardwareBufferFormatPropertiesANDROID* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     format = in_struct->format;
     externalFormat = in_struct->externalFormat;
     formatFeatures = in_struct->formatFeatures;
@@ -18167,12 +19905,12 @@ void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(const VkAnd
     suggestedYcbcrRange = in_struct->suggestedYcbcrRange;
     suggestedXChromaOffset = in_struct->suggestedXChromaOffset;
     suggestedYChromaOffset = in_struct->suggestedYChromaOffset;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(const safe_VkAndroidHardwareBufferFormatPropertiesANDROID* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     format = src->format;
     externalFormat = src->externalFormat;
     formatFeatures = src->formatFeatures;
@@ -18181,6 +19919,7 @@ void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(const safe_
     suggestedYcbcrRange = src->suggestedYcbcrRange;
     suggestedXChromaOffset = src->suggestedXChromaOffset;
     suggestedYChromaOffset = src->suggestedYChromaOffset;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
@@ -18189,20 +19928,21 @@ void safe_VkAndroidHardwareBufferFormatPropertiesANDROID::initialize(const safe_
 
 safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID(const VkImportAndroidHardwareBufferInfoANDROID* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     buffer(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     buffer = in_struct->buffer;
 }
 
 safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID() :
+    pNext(nullptr),
     buffer(nullptr)
 {}
 
 safe_VkImportAndroidHardwareBufferInfoANDROID::safe_VkImportAndroidHardwareBufferInfoANDROID(const safe_VkImportAndroidHardwareBufferInfoANDROID& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
+    pNext = SafePnextCopy(src.pNext);
     buffer = src.buffer;
 }
 
@@ -18210,9 +19950,11 @@ safe_VkImportAndroidHardwareBufferInfoANDROID& safe_VkImportAndroidHardwareBuffe
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
+    pNext = SafePnextCopy(src.pNext);
     buffer = src.buffer;
 
     return *this;
@@ -18220,19 +19962,21 @@ safe_VkImportAndroidHardwareBufferInfoANDROID& safe_VkImportAndroidHardwareBuffe
 
 safe_VkImportAndroidHardwareBufferInfoANDROID::~safe_VkImportAndroidHardwareBufferInfoANDROID()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const VkImportAndroidHardwareBufferInfoANDROID* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
+    pNext = SafePnextCopy(in_struct->pNext);
     buffer = in_struct->buffer;
 }
 
 void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const safe_VkImportAndroidHardwareBufferInfoANDROID* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
+    pNext = SafePnextCopy(src->pNext);
     buffer = src->buffer;
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
@@ -18242,49 +19986,54 @@ void safe_VkImportAndroidHardwareBufferInfoANDROID::initialize(const safe_VkImpo
 
 safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memory(in_struct->memory)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID()
+safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::safe_VkMemoryGetAndroidHardwareBufferInfoANDROID(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::operator=(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memory = src.memory;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::~safe_VkMemoryGetAndroidHardwareBufferInfoANDROID()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const VkMemoryGetAndroidHardwareBufferInfoANDROID* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memory = in_struct->memory;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const safe_VkMemoryGetAndroidHardwareBufferInfoANDROID* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memory = src->memory;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
@@ -18293,378 +20042,414 @@ void safe_VkMemoryGetAndroidHardwareBufferInfoANDROID::initialize(const safe_VkM
 
 safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const VkExternalFormatANDROID* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     externalFormat(in_struct->externalFormat)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID()
+safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID() :
+    pNext(nullptr)
 {}
 
 safe_VkExternalFormatANDROID::safe_VkExternalFormatANDROID(const safe_VkExternalFormatANDROID& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     externalFormat = src.externalFormat;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkExternalFormatANDROID& safe_VkExternalFormatANDROID::operator=(const safe_VkExternalFormatANDROID& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     externalFormat = src.externalFormat;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkExternalFormatANDROID::~safe_VkExternalFormatANDROID()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkExternalFormatANDROID::initialize(const VkExternalFormatANDROID* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     externalFormat = in_struct->externalFormat;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkExternalFormatANDROID::initialize(const safe_VkExternalFormatANDROID* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     externalFormat = src->externalFormat;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_ANDROID_KHR
 
 
 safe_VkSamplerReductionModeCreateInfoEXT::safe_VkSamplerReductionModeCreateInfoEXT(const VkSamplerReductionModeCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     reductionMode(in_struct->reductionMode)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSamplerReductionModeCreateInfoEXT::safe_VkSamplerReductionModeCreateInfoEXT()
+safe_VkSamplerReductionModeCreateInfoEXT::safe_VkSamplerReductionModeCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkSamplerReductionModeCreateInfoEXT::safe_VkSamplerReductionModeCreateInfoEXT(const safe_VkSamplerReductionModeCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     reductionMode = src.reductionMode;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSamplerReductionModeCreateInfoEXT& safe_VkSamplerReductionModeCreateInfoEXT::operator=(const safe_VkSamplerReductionModeCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     reductionMode = src.reductionMode;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSamplerReductionModeCreateInfoEXT::~safe_VkSamplerReductionModeCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSamplerReductionModeCreateInfoEXT::initialize(const VkSamplerReductionModeCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     reductionMode = in_struct->reductionMode;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSamplerReductionModeCreateInfoEXT::initialize(const safe_VkSamplerReductionModeCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     reductionMode = src->reductionMode;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     filterMinmaxSingleComponentFormats(in_struct->filterMinmaxSingleComponentFormats),
     filterMinmaxImageComponentMapping(in_struct->filterMinmaxImageComponentMapping)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
+safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     filterMinmaxSingleComponentFormats = src.filterMinmaxSingleComponentFormats;
     filterMinmaxImageComponentMapping = src.filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::operator=(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     filterMinmaxSingleComponentFormats = src.filterMinmaxSingleComponentFormats;
     filterMinmaxImageComponentMapping = src.filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::~safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::initialize(const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     filterMinmaxSingleComponentFormats = in_struct->filterMinmaxSingleComponentFormats;
     filterMinmaxImageComponentMapping = in_struct->filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT::initialize(const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     filterMinmaxSingleComponentFormats = src->filterMinmaxSingleComponentFormats;
     filterMinmaxImageComponentMapping = src->filterMinmaxImageComponentMapping;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     inlineUniformBlock(in_struct->inlineUniformBlock),
     descriptorBindingInlineUniformBlockUpdateAfterBind(in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT()
+safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     inlineUniformBlock = src.inlineUniformBlock;
     descriptorBindingInlineUniformBlockUpdateAfterBind = src.descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::operator=(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     inlineUniformBlock = src.inlineUniformBlock;
     descriptorBindingInlineUniformBlockUpdateAfterBind = src.descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::~safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::initialize(const VkPhysicalDeviceInlineUniformBlockFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     inlineUniformBlock = in_struct->inlineUniformBlock;
     descriptorBindingInlineUniformBlockUpdateAfterBind = in_struct->descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT::initialize(const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     inlineUniformBlock = src->inlineUniformBlock;
     descriptorBindingInlineUniformBlockUpdateAfterBind = src->descriptorBindingInlineUniformBlockUpdateAfterBind;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxInlineUniformBlockSize(in_struct->maxInlineUniformBlockSize),
     maxPerStageDescriptorInlineUniformBlocks(in_struct->maxPerStageDescriptorInlineUniformBlocks),
     maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks(in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks),
     maxDescriptorSetInlineUniformBlocks(in_struct->maxDescriptorSetInlineUniformBlocks),
     maxDescriptorSetUpdateAfterBindInlineUniformBlocks(in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT()
+safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxInlineUniformBlockSize = src.maxInlineUniformBlockSize;
     maxPerStageDescriptorInlineUniformBlocks = src.maxPerStageDescriptorInlineUniformBlocks;
     maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
     maxDescriptorSetInlineUniformBlocks = src.maxDescriptorSetInlineUniformBlocks;
     maxDescriptorSetUpdateAfterBindInlineUniformBlocks = src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::operator=(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxInlineUniformBlockSize = src.maxInlineUniformBlockSize;
     maxPerStageDescriptorInlineUniformBlocks = src.maxPerStageDescriptorInlineUniformBlocks;
     maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = src.maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
     maxDescriptorSetInlineUniformBlocks = src.maxDescriptorSetInlineUniformBlocks;
     maxDescriptorSetUpdateAfterBindInlineUniformBlocks = src.maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::~safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::initialize(const VkPhysicalDeviceInlineUniformBlockPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxInlineUniformBlockSize = in_struct->maxInlineUniformBlockSize;
     maxPerStageDescriptorInlineUniformBlocks = in_struct->maxPerStageDescriptorInlineUniformBlocks;
     maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = in_struct->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
     maxDescriptorSetInlineUniformBlocks = in_struct->maxDescriptorSetInlineUniformBlocks;
     maxDescriptorSetUpdateAfterBindInlineUniformBlocks = in_struct->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT::initialize(const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxInlineUniformBlockSize = src->maxInlineUniformBlockSize;
     maxPerStageDescriptorInlineUniformBlocks = src->maxPerStageDescriptorInlineUniformBlocks;
     maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks = src->maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
     maxDescriptorSetInlineUniformBlocks = src->maxDescriptorSetInlineUniformBlocks;
     maxDescriptorSetUpdateAfterBindInlineUniformBlocks = src->maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkWriteDescriptorSetInlineUniformBlockEXT::safe_VkWriteDescriptorSetInlineUniformBlockEXT(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     dataSize(in_struct->dataSize),
     pData(in_struct->pData)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkWriteDescriptorSetInlineUniformBlockEXT::safe_VkWriteDescriptorSetInlineUniformBlockEXT()
+safe_VkWriteDescriptorSetInlineUniformBlockEXT::safe_VkWriteDescriptorSetInlineUniformBlockEXT() :
+    pNext(nullptr),
+    pData(nullptr)
 {}
 
 safe_VkWriteDescriptorSetInlineUniformBlockEXT::safe_VkWriteDescriptorSetInlineUniformBlockEXT(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     dataSize = src.dataSize;
     pData = src.pData;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkWriteDescriptorSetInlineUniformBlockEXT& safe_VkWriteDescriptorSetInlineUniformBlockEXT::operator=(const safe_VkWriteDescriptorSetInlineUniformBlockEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     dataSize = src.dataSize;
     pData = src.pData;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkWriteDescriptorSetInlineUniformBlockEXT::~safe_VkWriteDescriptorSetInlineUniformBlockEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkWriteDescriptorSetInlineUniformBlockEXT::initialize(const VkWriteDescriptorSetInlineUniformBlockEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     dataSize = in_struct->dataSize;
     pData = in_struct->pData;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkWriteDescriptorSetInlineUniformBlockEXT::initialize(const safe_VkWriteDescriptorSetInlineUniformBlockEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     dataSize = src->dataSize;
     pData = src->pData;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxInlineUniformBlockBindings(in_struct->maxInlineUniformBlockBindings)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT()
+safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxInlineUniformBlockBindings = src.maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::operator=(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxInlineUniformBlockBindings = src.maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::~safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::initialize(const VkDescriptorPoolInlineUniformBlockCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxInlineUniformBlockBindings = in_struct->maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT::initialize(const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxInlineUniformBlockBindings = src->maxInlineUniformBlockBindings;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const VkSampleLocationsInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     sampleLocationsPerPixel(in_struct->sampleLocationsPerPixel),
     sampleLocationGridSize(in_struct->sampleLocationGridSize),
     sampleLocationsCount(in_struct->sampleLocationsCount),
     pSampleLocations(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pSampleLocations) {
         pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount];
         memcpy ((void *)pSampleLocations, (void *)in_struct->pSampleLocations, sizeof(VkSampleLocationEXT)*in_struct->sampleLocationsCount);
@@ -18672,17 +20457,18 @@ safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const VkSampleLocat
 }
 
 safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT() :
+    pNext(nullptr),
     pSampleLocations(nullptr)
 {}
 
 safe_VkSampleLocationsInfoEXT::safe_VkSampleLocationsInfoEXT(const safe_VkSampleLocationsInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     sampleLocationsPerPixel = src.sampleLocationsPerPixel;
     sampleLocationGridSize = src.sampleLocationGridSize;
     sampleLocationsCount = src.sampleLocationsCount;
     pSampleLocations = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pSampleLocations) {
         pSampleLocations = new VkSampleLocationEXT[src.sampleLocationsCount];
         memcpy ((void *)pSampleLocations, (void *)src.pSampleLocations, sizeof(VkSampleLocationEXT)*src.sampleLocationsCount);
@@ -18695,13 +20481,15 @@ safe_VkSampleLocationsInfoEXT& safe_VkSampleLocationsInfoEXT::operator=(const sa
 
     if (pSampleLocations)
         delete[] pSampleLocations;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     sampleLocationsPerPixel = src.sampleLocationsPerPixel;
     sampleLocationGridSize = src.sampleLocationGridSize;
     sampleLocationsCount = src.sampleLocationsCount;
     pSampleLocations = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pSampleLocations) {
         pSampleLocations = new VkSampleLocationEXT[src.sampleLocationsCount];
         memcpy ((void *)pSampleLocations, (void *)src.pSampleLocations, sizeof(VkSampleLocationEXT)*src.sampleLocationsCount);
@@ -18714,16 +20502,18 @@ safe_VkSampleLocationsInfoEXT::~safe_VkSampleLocationsInfoEXT()
 {
     if (pSampleLocations)
         delete[] pSampleLocations;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSampleLocationsInfoEXT::initialize(const VkSampleLocationsInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     sampleLocationsPerPixel = in_struct->sampleLocationsPerPixel;
     sampleLocationGridSize = in_struct->sampleLocationGridSize;
     sampleLocationsCount = in_struct->sampleLocationsCount;
     pSampleLocations = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pSampleLocations) {
         pSampleLocations = new VkSampleLocationEXT[in_struct->sampleLocationsCount];
         memcpy ((void *)pSampleLocations, (void *)in_struct->pSampleLocations, sizeof(VkSampleLocationEXT)*in_struct->sampleLocationsCount);
@@ -18733,11 +20523,11 @@ void safe_VkSampleLocationsInfoEXT::initialize(const VkSampleLocationsInfoEXT* i
 void safe_VkSampleLocationsInfoEXT::initialize(const safe_VkSampleLocationsInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     sampleLocationsPerPixel = src->sampleLocationsPerPixel;
     sampleLocationGridSize = src->sampleLocationGridSize;
     sampleLocationsCount = src->sampleLocationsCount;
     pSampleLocations = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pSampleLocations) {
         pSampleLocations = new VkSampleLocationEXT[src->sampleLocationsCount];
         memcpy ((void *)pSampleLocations, (void *)src->pSampleLocations, sizeof(VkSampleLocationEXT)*src->sampleLocationsCount);
@@ -18746,12 +20536,12 @@ void safe_VkSampleLocationsInfoEXT::initialize(const safe_VkSampleLocationsInfoE
 
 safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     attachmentInitialSampleLocationsCount(in_struct->attachmentInitialSampleLocationsCount),
     pAttachmentInitialSampleLocations(nullptr),
     postSubpassSampleLocationsCount(in_struct->postSubpassSampleLocationsCount),
     pPostSubpassSampleLocations(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttachmentInitialSampleLocations) {
         pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
         memcpy ((void *)pAttachmentInitialSampleLocations, (void *)in_struct->pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*in_struct->attachmentInitialSampleLocationsCount);
@@ -18763,6 +20553,7 @@ safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBe
 }
 
 safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT() :
+    pNext(nullptr),
     pAttachmentInitialSampleLocations(nullptr),
     pPostSubpassSampleLocations(nullptr)
 {}
@@ -18770,11 +20561,11 @@ safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBe
 safe_VkRenderPassSampleLocationsBeginInfoEXT::safe_VkRenderPassSampleLocationsBeginInfoEXT(const safe_VkRenderPassSampleLocationsBeginInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     attachmentInitialSampleLocationsCount = src.attachmentInitialSampleLocationsCount;
     pAttachmentInitialSampleLocations = nullptr;
     postSubpassSampleLocationsCount = src.postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttachmentInitialSampleLocations) {
         pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[src.attachmentInitialSampleLocationsCount];
         memcpy ((void *)pAttachmentInitialSampleLocations, (void *)src.pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*src.attachmentInitialSampleLocationsCount);
@@ -18793,13 +20584,15 @@ safe_VkRenderPassSampleLocationsBeginInfoEXT& safe_VkRenderPassSampleLocationsBe
         delete[] pAttachmentInitialSampleLocations;
     if (pPostSubpassSampleLocations)
         delete[] pPostSubpassSampleLocations;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     attachmentInitialSampleLocationsCount = src.attachmentInitialSampleLocationsCount;
     pAttachmentInitialSampleLocations = nullptr;
     postSubpassSampleLocationsCount = src.postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pAttachmentInitialSampleLocations) {
         pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[src.attachmentInitialSampleLocationsCount];
         memcpy ((void *)pAttachmentInitialSampleLocations, (void *)src.pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*src.attachmentInitialSampleLocationsCount);
@@ -18818,16 +20611,18 @@ safe_VkRenderPassSampleLocationsBeginInfoEXT::~safe_VkRenderPassSampleLocationsB
         delete[] pAttachmentInitialSampleLocations;
     if (pPostSubpassSampleLocations)
         delete[] pPostSubpassSampleLocations;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const VkRenderPassSampleLocationsBeginInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     attachmentInitialSampleLocationsCount = in_struct->attachmentInitialSampleLocationsCount;
     pAttachmentInitialSampleLocations = nullptr;
     postSubpassSampleLocationsCount = in_struct->postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pAttachmentInitialSampleLocations) {
         pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[in_struct->attachmentInitialSampleLocationsCount];
         memcpy ((void *)pAttachmentInitialSampleLocations, (void *)in_struct->pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*in_struct->attachmentInitialSampleLocationsCount);
@@ -18841,11 +20636,11 @@ void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const VkRenderPass
 void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const safe_VkRenderPassSampleLocationsBeginInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     attachmentInitialSampleLocationsCount = src->attachmentInitialSampleLocationsCount;
     pAttachmentInitialSampleLocations = nullptr;
     postSubpassSampleLocationsCount = src->postSubpassSampleLocationsCount;
     pPostSubpassSampleLocations = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pAttachmentInitialSampleLocations) {
         pAttachmentInitialSampleLocations = new VkAttachmentSampleLocationsEXT[src->attachmentInitialSampleLocationsCount];
         memcpy ((void *)pAttachmentInitialSampleLocations, (void *)src->pAttachmentInitialSampleLocations, sizeof(VkAttachmentSampleLocationsEXT)*src->attachmentInitialSampleLocationsCount);
@@ -18858,81 +20653,87 @@ void safe_VkRenderPassSampleLocationsBeginInfoEXT::initialize(const safe_VkRende
 
 safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     sampleLocationsEnable(in_struct->sampleLocationsEnable),
     sampleLocationsInfo(&in_struct->sampleLocationsInfo)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT()
+safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineSampleLocationsStateCreateInfoEXT::safe_VkPipelineSampleLocationsStateCreateInfoEXT(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     sampleLocationsEnable = src.sampleLocationsEnable;
     sampleLocationsInfo.initialize(&src.sampleLocationsInfo);
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineSampleLocationsStateCreateInfoEXT& safe_VkPipelineSampleLocationsStateCreateInfoEXT::operator=(const safe_VkPipelineSampleLocationsStateCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     sampleLocationsEnable = src.sampleLocationsEnable;
     sampleLocationsInfo.initialize(&src.sampleLocationsInfo);
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineSampleLocationsStateCreateInfoEXT::~safe_VkPipelineSampleLocationsStateCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const VkPipelineSampleLocationsStateCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     sampleLocationsEnable = in_struct->sampleLocationsEnable;
     sampleLocationsInfo.initialize(&in_struct->sampleLocationsInfo);
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineSampleLocationsStateCreateInfoEXT::initialize(const safe_VkPipelineSampleLocationsStateCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     sampleLocationsEnable = src->sampleLocationsEnable;
     sampleLocationsInfo.initialize(&src->sampleLocationsInfo);
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     sampleLocationSampleCounts(in_struct->sampleLocationSampleCounts),
     maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize),
     sampleLocationSubPixelBits(in_struct->sampleLocationSubPixelBits),
     variableSampleLocations(in_struct->variableSampleLocations)
 {
-    for (uint32_t i=0; i<2; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < 2; ++i) {
         sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i];
     }
 }
 
-safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT()
+safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     sampleLocationSampleCounts = src.sampleLocationSampleCounts;
     maxSampleLocationGridSize = src.maxSampleLocationGridSize;
     sampleLocationSubPixelBits = src.sampleLocationSubPixelBits;
     variableSampleLocations = src.variableSampleLocations;
-    for (uint32_t i=0; i<2; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < 2; ++i) {
         sampleLocationCoordinateRange[i] = src.sampleLocationCoordinateRange[i];
     }
 }
@@ -18941,14 +20742,16 @@ safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& safe_VkPhysicalDeviceSampleLo
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     sampleLocationSampleCounts = src.sampleLocationSampleCounts;
     maxSampleLocationGridSize = src.maxSampleLocationGridSize;
     sampleLocationSubPixelBits = src.sampleLocationSubPixelBits;
     variableSampleLocations = src.variableSampleLocations;
-    for (uint32_t i=0; i<2; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < 2; ++i) {
         sampleLocationCoordinateRange[i] = src.sampleLocationCoordinateRange[i];
     }
 
@@ -18957,17 +20760,19 @@ safe_VkPhysicalDeviceSampleLocationsPropertiesEXT& safe_VkPhysicalDeviceSampleLo
 
 safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::~safe_VkPhysicalDeviceSampleLocationsPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(const VkPhysicalDeviceSampleLocationsPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     sampleLocationSampleCounts = in_struct->sampleLocationSampleCounts;
     maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize;
     sampleLocationSubPixelBits = in_struct->sampleLocationSubPixelBits;
     variableSampleLocations = in_struct->variableSampleLocations;
-    for (uint32_t i=0; i<2; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < 2; ++i) {
         sampleLocationCoordinateRange[i] = in_struct->sampleLocationCoordinateRange[i];
     }
 }
@@ -18975,113 +20780,122 @@ void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(const VkPhysi
 void safe_VkPhysicalDeviceSampleLocationsPropertiesEXT::initialize(const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     sampleLocationSampleCounts = src->sampleLocationSampleCounts;
     maxSampleLocationGridSize = src->maxSampleLocationGridSize;
     sampleLocationSubPixelBits = src->sampleLocationSubPixelBits;
     variableSampleLocations = src->variableSampleLocations;
-    for (uint32_t i=0; i<2; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < 2; ++i) {
         sampleLocationCoordinateRange[i] = src->sampleLocationCoordinateRange[i];
     }
 }
 
 safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const VkMultisamplePropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxSampleLocationGridSize(in_struct->maxSampleLocationGridSize)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT()
+safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkMultisamplePropertiesEXT::safe_VkMultisamplePropertiesEXT(const safe_VkMultisamplePropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxSampleLocationGridSize = src.maxSampleLocationGridSize;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMultisamplePropertiesEXT& safe_VkMultisamplePropertiesEXT::operator=(const safe_VkMultisamplePropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxSampleLocationGridSize = src.maxSampleLocationGridSize;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMultisamplePropertiesEXT::~safe_VkMultisamplePropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMultisamplePropertiesEXT::initialize(const VkMultisamplePropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxSampleLocationGridSize = in_struct->maxSampleLocationGridSize;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMultisamplePropertiesEXT::initialize(const safe_VkMultisamplePropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxSampleLocationGridSize = src->maxSampleLocationGridSize;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     advancedBlendCoherentOperations(in_struct->advancedBlendCoherentOperations)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT()
+safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     advancedBlendCoherentOperations = src.advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     advancedBlendCoherentOperations = src.advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     advancedBlendCoherentOperations = in_struct->advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT::initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     advancedBlendCoherentOperations = src->advancedBlendCoherentOperations;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     advancedBlendMaxColorAttachments(in_struct->advancedBlendMaxColorAttachments),
     advancedBlendIndependentBlend(in_struct->advancedBlendIndependentBlend),
     advancedBlendNonPremultipliedSrcColor(in_struct->advancedBlendNonPremultipliedSrcColor),
@@ -19089,191 +20903,207 @@ safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceB
     advancedBlendCorrelatedOverlap(in_struct->advancedBlendCorrelatedOverlap),
     advancedBlendAllOperations(in_struct->advancedBlendAllOperations)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT()
+safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     advancedBlendMaxColorAttachments = src.advancedBlendMaxColorAttachments;
     advancedBlendIndependentBlend = src.advancedBlendIndependentBlend;
     advancedBlendNonPremultipliedSrcColor = src.advancedBlendNonPremultipliedSrcColor;
     advancedBlendNonPremultipliedDstColor = src.advancedBlendNonPremultipliedDstColor;
     advancedBlendCorrelatedOverlap = src.advancedBlendCorrelatedOverlap;
     advancedBlendAllOperations = src.advancedBlendAllOperations;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::operator=(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     advancedBlendMaxColorAttachments = src.advancedBlendMaxColorAttachments;
     advancedBlendIndependentBlend = src.advancedBlendIndependentBlend;
     advancedBlendNonPremultipliedSrcColor = src.advancedBlendNonPremultipliedSrcColor;
     advancedBlendNonPremultipliedDstColor = src.advancedBlendNonPremultipliedDstColor;
     advancedBlendCorrelatedOverlap = src.advancedBlendCorrelatedOverlap;
     advancedBlendAllOperations = src.advancedBlendAllOperations;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::~safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     advancedBlendMaxColorAttachments = in_struct->advancedBlendMaxColorAttachments;
     advancedBlendIndependentBlend = in_struct->advancedBlendIndependentBlend;
     advancedBlendNonPremultipliedSrcColor = in_struct->advancedBlendNonPremultipliedSrcColor;
     advancedBlendNonPremultipliedDstColor = in_struct->advancedBlendNonPremultipliedDstColor;
     advancedBlendCorrelatedOverlap = in_struct->advancedBlendCorrelatedOverlap;
     advancedBlendAllOperations = in_struct->advancedBlendAllOperations;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT::initialize(const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     advancedBlendMaxColorAttachments = src->advancedBlendMaxColorAttachments;
     advancedBlendIndependentBlend = src->advancedBlendIndependentBlend;
     advancedBlendNonPremultipliedSrcColor = src->advancedBlendNonPremultipliedSrcColor;
     advancedBlendNonPremultipliedDstColor = src->advancedBlendNonPremultipliedDstColor;
     advancedBlendCorrelatedOverlap = src->advancedBlendCorrelatedOverlap;
     advancedBlendAllOperations = src->advancedBlendAllOperations;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     srcPremultiplied(in_struct->srcPremultiplied),
     dstPremultiplied(in_struct->dstPremultiplied),
     blendOverlap(in_struct->blendOverlap)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT()
+safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     srcPremultiplied = src.srcPremultiplied;
     dstPremultiplied = src.dstPremultiplied;
     blendOverlap = src.blendOverlap;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::operator=(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     srcPremultiplied = src.srcPremultiplied;
     dstPremultiplied = src.dstPremultiplied;
     blendOverlap = src.blendOverlap;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::~safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(const VkPipelineColorBlendAdvancedStateCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     srcPremultiplied = in_struct->srcPremultiplied;
     dstPremultiplied = in_struct->dstPremultiplied;
     blendOverlap = in_struct->blendOverlap;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT::initialize(const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     srcPremultiplied = src->srcPremultiplied;
     dstPremultiplied = src->dstPremultiplied;
     blendOverlap = src->blendOverlap;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     coverageToColorEnable(in_struct->coverageToColorEnable),
     coverageToColorLocation(in_struct->coverageToColorLocation)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV()
+safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineCoverageToColorStateCreateInfoNV::safe_VkPipelineCoverageToColorStateCreateInfoNV(const safe_VkPipelineCoverageToColorStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     coverageToColorEnable = src.coverageToColorEnable;
     coverageToColorLocation = src.coverageToColorLocation;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineCoverageToColorStateCreateInfoNV& safe_VkPipelineCoverageToColorStateCreateInfoNV::operator=(const safe_VkPipelineCoverageToColorStateCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     coverageToColorEnable = src.coverageToColorEnable;
     coverageToColorLocation = src.coverageToColorLocation;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineCoverageToColorStateCreateInfoNV::~safe_VkPipelineCoverageToColorStateCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const VkPipelineCoverageToColorStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     coverageToColorEnable = in_struct->coverageToColorEnable;
     coverageToColorLocation = in_struct->coverageToColorLocation;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineCoverageToColorStateCreateInfoNV::initialize(const safe_VkPipelineCoverageToColorStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     coverageToColorEnable = src->coverageToColorEnable;
     coverageToColorLocation = src->coverageToColorLocation;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     coverageModulationMode(in_struct->coverageModulationMode),
     coverageModulationTableEnable(in_struct->coverageModulationTableEnable),
     coverageModulationTableCount(in_struct->coverageModulationTableCount),
     pCoverageModulationTable(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pCoverageModulationTable) {
         pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
         memcpy ((void *)pCoverageModulationTable, (void *)in_struct->pCoverageModulationTable, sizeof(float)*in_struct->coverageModulationTableCount);
@@ -19281,18 +21111,19 @@ safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModul
 }
 
 safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV() :
+    pNext(nullptr),
     pCoverageModulationTable(nullptr)
 {}
 
 safe_VkPipelineCoverageModulationStateCreateInfoNV::safe_VkPipelineCoverageModulationStateCreateInfoNV(const safe_VkPipelineCoverageModulationStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     coverageModulationMode = src.coverageModulationMode;
     coverageModulationTableEnable = src.coverageModulationTableEnable;
     coverageModulationTableCount = src.coverageModulationTableCount;
     pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pCoverageModulationTable) {
         pCoverageModulationTable = new float[src.coverageModulationTableCount];
         memcpy ((void *)pCoverageModulationTable, (void *)src.pCoverageModulationTable, sizeof(float)*src.coverageModulationTableCount);
@@ -19305,14 +21136,16 @@ safe_VkPipelineCoverageModulationStateCreateInfoNV& safe_VkPipelineCoverageModul
 
     if (pCoverageModulationTable)
         delete[] pCoverageModulationTable;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     coverageModulationMode = src.coverageModulationMode;
     coverageModulationTableEnable = src.coverageModulationTableEnable;
     coverageModulationTableCount = src.coverageModulationTableCount;
     pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pCoverageModulationTable) {
         pCoverageModulationTable = new float[src.coverageModulationTableCount];
         memcpy ((void *)pCoverageModulationTable, (void *)src.pCoverageModulationTable, sizeof(float)*src.coverageModulationTableCount);
@@ -19325,17 +21158,19 @@ safe_VkPipelineCoverageModulationStateCreateInfoNV::~safe_VkPipelineCoverageModu
 {
     if (pCoverageModulationTable)
         delete[] pCoverageModulationTable;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const VkPipelineCoverageModulationStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     coverageModulationMode = in_struct->coverageModulationMode;
     coverageModulationTableEnable = in_struct->coverageModulationTableEnable;
     coverageModulationTableCount = in_struct->coverageModulationTableCount;
     pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pCoverageModulationTable) {
         pCoverageModulationTable = new float[in_struct->coverageModulationTableCount];
         memcpy ((void *)pCoverageModulationTable, (void *)in_struct->pCoverageModulationTable, sizeof(float)*in_struct->coverageModulationTableCount);
@@ -19345,12 +21180,12 @@ void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const VkPipe
 void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const safe_VkPipelineCoverageModulationStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     coverageModulationMode = src->coverageModulationMode;
     coverageModulationTableEnable = src->coverageModulationTableEnable;
     coverageModulationTableCount = src->coverageModulationTableCount;
     pCoverageModulationTable = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pCoverageModulationTable) {
         pCoverageModulationTable = new float[src->coverageModulationTableCount];
         memcpy ((void *)pCoverageModulationTable, (void *)src->pCoverageModulationTable, sizeof(float)*src->coverageModulationTableCount);
@@ -19359,109 +21194,119 @@ void safe_VkPipelineCoverageModulationStateCreateInfoNV::initialize(const safe_V
 
 safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderSMCount(in_struct->shaderSMCount),
     shaderWarpsPerSM(in_struct->shaderWarpsPerSM)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV()
+safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderSMCount = src.shaderSMCount;
     shaderWarpsPerSM = src.shaderWarpsPerSM;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderSMCount = src.shaderSMCount;
     shaderWarpsPerSM = src.shaderWarpsPerSM;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderSMCount = in_struct->shaderSMCount;
     shaderWarpsPerSM = in_struct->shaderWarpsPerSM;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV::initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderSMCount = src->shaderSMCount;
     shaderWarpsPerSM = src->shaderWarpsPerSM;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderSMBuiltins(in_struct->shaderSMBuiltins)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV()
+safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderSMBuiltins = src.shaderSMBuiltins;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::operator=(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderSMBuiltins = src.shaderSMBuiltins;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::~safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderSMBuiltins = in_struct->shaderSMBuiltins;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV::initialize(const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderSMBuiltins = src->shaderSMBuiltins;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT(const VkDrmFormatModifierPropertiesListEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     drmFormatModifierCount(in_struct->drmFormatModifierCount),
     pDrmFormatModifierProperties(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDrmFormatModifierProperties) {
         pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifierProperties, (void *)in_struct->pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*in_struct->drmFormatModifierCount);
@@ -19469,15 +21314,16 @@ safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesLis
 }
 
 safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT() :
+    pNext(nullptr),
     pDrmFormatModifierProperties(nullptr)
 {}
 
 safe_VkDrmFormatModifierPropertiesListEXT::safe_VkDrmFormatModifierPropertiesListEXT(const safe_VkDrmFormatModifierPropertiesListEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifierCount = src.drmFormatModifierCount;
     pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDrmFormatModifierProperties) {
         pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[src.drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifierProperties, (void *)src.pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*src.drmFormatModifierCount);
@@ -19490,11 +21336,13 @@ safe_VkDrmFormatModifierPropertiesListEXT& safe_VkDrmFormatModifierPropertiesLis
 
     if (pDrmFormatModifierProperties)
         delete[] pDrmFormatModifierProperties;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifierCount = src.drmFormatModifierCount;
     pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDrmFormatModifierProperties) {
         pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[src.drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifierProperties, (void *)src.pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*src.drmFormatModifierCount);
@@ -19507,14 +21355,16 @@ safe_VkDrmFormatModifierPropertiesListEXT::~safe_VkDrmFormatModifierPropertiesLi
 {
     if (pDrmFormatModifierProperties)
         delete[] pDrmFormatModifierProperties;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const VkDrmFormatModifierPropertiesListEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     drmFormatModifierCount = in_struct->drmFormatModifierCount;
     pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDrmFormatModifierProperties) {
         pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[in_struct->drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifierProperties, (void *)in_struct->pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*in_struct->drmFormatModifierCount);
@@ -19524,9 +21374,9 @@ void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const VkDrmFormatModi
 void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const safe_VkDrmFormatModifierPropertiesListEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     drmFormatModifierCount = src->drmFormatModifierCount;
     pDrmFormatModifierProperties = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDrmFormatModifierProperties) {
         pDrmFormatModifierProperties = new VkDrmFormatModifierPropertiesEXT[src->drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifierProperties, (void *)src->pDrmFormatModifierProperties, sizeof(VkDrmFormatModifierPropertiesEXT)*src->drmFormatModifierCount);
@@ -19535,12 +21385,12 @@ void safe_VkDrmFormatModifierPropertiesListEXT::initialize(const safe_VkDrmForma
 
 safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     drmFormatModifier(in_struct->drmFormatModifier),
     sharingMode(in_struct->sharingMode),
     queueFamilyIndexCount(in_struct->queueFamilyIndexCount),
     pQueueFamilyIndices(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -19548,17 +21398,18 @@ safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDr
 }
 
 safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT() :
+    pNext(nullptr),
     pQueueFamilyIndices(nullptr)
 {}
 
 safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifier = src.drmFormatModifier;
     sharingMode = src.sharingMode;
     queueFamilyIndexCount = src.queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -19571,13 +21422,15 @@ safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT& safe_VkPhysicalDeviceImageDr
 
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifier = src.drmFormatModifier;
     sharingMode = src.sharingMode;
     queueFamilyIndexCount = src.queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src.queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src.pQueueFamilyIndices, sizeof(uint32_t)*src.queueFamilyIndexCount);
@@ -19590,16 +21443,18 @@ safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::~safe_VkPhysicalDeviceImageD
 {
     if (pQueueFamilyIndices)
         delete[] pQueueFamilyIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     drmFormatModifier = in_struct->drmFormatModifier;
     sharingMode = in_struct->sharingMode;
     queueFamilyIndexCount = in_struct->queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[in_struct->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)in_struct->pQueueFamilyIndices, sizeof(uint32_t)*in_struct->queueFamilyIndexCount);
@@ -19609,11 +21464,11 @@ void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const VkPhys
 void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     drmFormatModifier = src->drmFormatModifier;
     sharingMode = src->sharingMode;
     queueFamilyIndexCount = src->queueFamilyIndexCount;
     pQueueFamilyIndices = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pQueueFamilyIndices) {
         pQueueFamilyIndices = new uint32_t[src->queueFamilyIndexCount];
         memcpy ((void *)pQueueFamilyIndices, (void *)src->pQueueFamilyIndices, sizeof(uint32_t)*src->queueFamilyIndexCount);
@@ -19622,10 +21477,10 @@ void safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT::initialize(const safe_V
 
 safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     drmFormatModifierCount(in_struct->drmFormatModifierCount),
     pDrmFormatModifiers(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDrmFormatModifiers) {
         pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifiers, (void *)in_struct->pDrmFormatModifiers, sizeof(uint64_t)*in_struct->drmFormatModifierCount);
@@ -19633,15 +21488,16 @@ safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierLis
 }
 
 safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT() :
+    pNext(nullptr),
     pDrmFormatModifiers(nullptr)
 {}
 
 safe_VkImageDrmFormatModifierListCreateInfoEXT::safe_VkImageDrmFormatModifierListCreateInfoEXT(const safe_VkImageDrmFormatModifierListCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifierCount = src.drmFormatModifierCount;
     pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDrmFormatModifiers) {
         pDrmFormatModifiers = new uint64_t[src.drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifiers, (void *)src.pDrmFormatModifiers, sizeof(uint64_t)*src.drmFormatModifierCount);
@@ -19654,11 +21510,13 @@ safe_VkImageDrmFormatModifierListCreateInfoEXT& safe_VkImageDrmFormatModifierLis
 
     if (pDrmFormatModifiers)
         delete[] pDrmFormatModifiers;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifierCount = src.drmFormatModifierCount;
     pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDrmFormatModifiers) {
         pDrmFormatModifiers = new uint64_t[src.drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifiers, (void *)src.pDrmFormatModifiers, sizeof(uint64_t)*src.drmFormatModifierCount);
@@ -19671,14 +21529,16 @@ safe_VkImageDrmFormatModifierListCreateInfoEXT::~safe_VkImageDrmFormatModifierLi
 {
     if (pDrmFormatModifiers)
         delete[] pDrmFormatModifiers;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const VkImageDrmFormatModifierListCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     drmFormatModifierCount = in_struct->drmFormatModifierCount;
     pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDrmFormatModifiers) {
         pDrmFormatModifiers = new uint64_t[in_struct->drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifiers, (void *)in_struct->pDrmFormatModifiers, sizeof(uint64_t)*in_struct->drmFormatModifierCount);
@@ -19688,9 +21548,9 @@ void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const VkImageDrm
 void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const safe_VkImageDrmFormatModifierListCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     drmFormatModifierCount = src->drmFormatModifierCount;
     pDrmFormatModifiers = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDrmFormatModifiers) {
         pDrmFormatModifiers = new uint64_t[src->drmFormatModifierCount];
         memcpy ((void *)pDrmFormatModifiers, (void *)src->pDrmFormatModifiers, sizeof(uint64_t)*src->drmFormatModifierCount);
@@ -19699,11 +21559,11 @@ void safe_VkImageDrmFormatModifierListCreateInfoEXT::initialize(const safe_VkIma
 
 safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     drmFormatModifier(in_struct->drmFormatModifier),
     drmFormatModifierPlaneCount(in_struct->drmFormatModifierPlaneCount),
     pPlaneLayouts(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPlaneLayouts) {
         pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount];
         memcpy ((void *)pPlaneLayouts, (void *)in_struct->pPlaneLayouts, sizeof(VkSubresourceLayout)*in_struct->drmFormatModifierPlaneCount);
@@ -19711,16 +21571,17 @@ safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifie
 }
 
 safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT() :
+    pNext(nullptr),
     pPlaneLayouts(nullptr)
 {}
 
 safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifier = src.drmFormatModifier;
     drmFormatModifierPlaneCount = src.drmFormatModifierPlaneCount;
     pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPlaneLayouts) {
         pPlaneLayouts = new VkSubresourceLayout[src.drmFormatModifierPlaneCount];
         memcpy ((void *)pPlaneLayouts, (void *)src.pPlaneLayouts, sizeof(VkSubresourceLayout)*src.drmFormatModifierPlaneCount);
@@ -19733,12 +21594,14 @@ safe_VkImageDrmFormatModifierExplicitCreateInfoEXT& safe_VkImageDrmFormatModifie
 
     if (pPlaneLayouts)
         delete[] pPlaneLayouts;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifier = src.drmFormatModifier;
     drmFormatModifierPlaneCount = src.drmFormatModifierPlaneCount;
     pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPlaneLayouts) {
         pPlaneLayouts = new VkSubresourceLayout[src.drmFormatModifierPlaneCount];
         memcpy ((void *)pPlaneLayouts, (void *)src.pPlaneLayouts, sizeof(VkSubresourceLayout)*src.drmFormatModifierPlaneCount);
@@ -19751,15 +21614,17 @@ safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::~safe_VkImageDrmFormatModifi
 {
     if (pPlaneLayouts)
         delete[] pPlaneLayouts;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const VkImageDrmFormatModifierExplicitCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     drmFormatModifier = in_struct->drmFormatModifier;
     drmFormatModifierPlaneCount = in_struct->drmFormatModifierPlaneCount;
     pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPlaneLayouts) {
         pPlaneLayouts = new VkSubresourceLayout[in_struct->drmFormatModifierPlaneCount];
         memcpy ((void *)pPlaneLayouts, (void *)in_struct->pPlaneLayouts, sizeof(VkSubresourceLayout)*in_struct->drmFormatModifierPlaneCount);
@@ -19769,10 +21634,10 @@ void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const VkImag
 void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     drmFormatModifier = src->drmFormatModifier;
     drmFormatModifierPlaneCount = src->drmFormatModifierPlaneCount;
     pPlaneLayouts = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pPlaneLayouts) {
         pPlaneLayouts = new VkSubresourceLayout[src->drmFormatModifierPlaneCount];
         memcpy ((void *)pPlaneLayouts, (void *)src->pPlaneLayouts, sizeof(VkSubresourceLayout)*src->drmFormatModifierPlaneCount);
@@ -19781,161 +21646,177 @@ void safe_VkImageDrmFormatModifierExplicitCreateInfoEXT::initialize(const safe_V
 
 safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT(const VkImageDrmFormatModifierPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     drmFormatModifier(in_struct->drmFormatModifier)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT()
+safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkImageDrmFormatModifierPropertiesEXT::safe_VkImageDrmFormatModifierPropertiesEXT(const safe_VkImageDrmFormatModifierPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifier = src.drmFormatModifier;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageDrmFormatModifierPropertiesEXT& safe_VkImageDrmFormatModifierPropertiesEXT::operator=(const safe_VkImageDrmFormatModifierPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     drmFormatModifier = src.drmFormatModifier;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageDrmFormatModifierPropertiesEXT::~safe_VkImageDrmFormatModifierPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const VkImageDrmFormatModifierPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     drmFormatModifier = in_struct->drmFormatModifier;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageDrmFormatModifierPropertiesEXT::initialize(const safe_VkImageDrmFormatModifierPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     drmFormatModifier = src->drmFormatModifier;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const VkValidationCacheCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     initialDataSize(in_struct->initialDataSize),
     pInitialData(in_struct->pInitialData)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT()
+safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT() :
+    pNext(nullptr),
+    pInitialData(nullptr)
 {}
 
 safe_VkValidationCacheCreateInfoEXT::safe_VkValidationCacheCreateInfoEXT(const safe_VkValidationCacheCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     initialDataSize = src.initialDataSize;
     pInitialData = src.pInitialData;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkValidationCacheCreateInfoEXT& safe_VkValidationCacheCreateInfoEXT::operator=(const safe_VkValidationCacheCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     initialDataSize = src.initialDataSize;
     pInitialData = src.pInitialData;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkValidationCacheCreateInfoEXT::~safe_VkValidationCacheCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkValidationCacheCreateInfoEXT::initialize(const VkValidationCacheCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     initialDataSize = in_struct->initialDataSize;
     pInitialData = in_struct->pInitialData;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkValidationCacheCreateInfoEXT::initialize(const safe_VkValidationCacheCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     initialDataSize = src->initialDataSize;
     pInitialData = src->pInitialData;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     validationCache(in_struct->validationCache)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT()
+safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkShaderModuleValidationCacheCreateInfoEXT::safe_VkShaderModuleValidationCacheCreateInfoEXT(const safe_VkShaderModuleValidationCacheCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     validationCache = src.validationCache;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkShaderModuleValidationCacheCreateInfoEXT& safe_VkShaderModuleValidationCacheCreateInfoEXT::operator=(const safe_VkShaderModuleValidationCacheCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     validationCache = src.validationCache;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkShaderModuleValidationCacheCreateInfoEXT::~safe_VkShaderModuleValidationCacheCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const VkShaderModuleValidationCacheCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     validationCache = in_struct->validationCache;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkShaderModuleValidationCacheCreateInfoEXT::initialize(const safe_VkShaderModuleValidationCacheCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     validationCache = src->validationCache;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     bindingCount(in_struct->bindingCount),
     pBindingFlags(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pBindingFlags) {
         pBindingFlags = new VkDescriptorBindingFlagsEXT[in_struct->bindingCount];
         memcpy ((void *)pBindingFlags, (void *)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlagsEXT)*in_struct->bindingCount);
@@ -19943,15 +21824,16 @@ safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::safe_VkDescriptorSetLayoutB
 }
 
 safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT() :
+    pNext(nullptr),
     pBindingFlags(nullptr)
 {}
 
 safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     bindingCount = src.bindingCount;
     pBindingFlags = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pBindingFlags) {
         pBindingFlags = new VkDescriptorBindingFlagsEXT[src.bindingCount];
         memcpy ((void *)pBindingFlags, (void *)src.pBindingFlags, sizeof(VkDescriptorBindingFlagsEXT)*src.bindingCount);
@@ -19964,11 +21846,13 @@ safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT& safe_VkDescriptorSetLayoutB
 
     if (pBindingFlags)
         delete[] pBindingFlags;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     bindingCount = src.bindingCount;
     pBindingFlags = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pBindingFlags) {
         pBindingFlags = new VkDescriptorBindingFlagsEXT[src.bindingCount];
         memcpy ((void *)pBindingFlags, (void *)src.pBindingFlags, sizeof(VkDescriptorBindingFlagsEXT)*src.bindingCount);
@@ -19981,14 +21865,16 @@ safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::~safe_VkDescriptorSetLayout
 {
     if (pBindingFlags)
         delete[] pBindingFlags;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::initialize(const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     bindingCount = in_struct->bindingCount;
     pBindingFlags = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pBindingFlags) {
         pBindingFlags = new VkDescriptorBindingFlagsEXT[in_struct->bindingCount];
         memcpy ((void *)pBindingFlags, (void *)in_struct->pBindingFlags, sizeof(VkDescriptorBindingFlagsEXT)*in_struct->bindingCount);
@@ -19998,9 +21884,9 @@ void safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::initialize(const VkDes
 void safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::initialize(const safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     bindingCount = src->bindingCount;
     pBindingFlags = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pBindingFlags) {
         pBindingFlags = new VkDescriptorBindingFlagsEXT[src->bindingCount];
         memcpy ((void *)pBindingFlags, (void *)src->pBindingFlags, sizeof(VkDescriptorBindingFlagsEXT)*src->bindingCount);
@@ -20009,7 +21895,6 @@ void safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT::initialize(const safe_
 
 safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderInputAttachmentArrayDynamicIndexing(in_struct->shaderInputAttachmentArrayDynamicIndexing),
     shaderUniformTexelBufferArrayDynamicIndexing(in_struct->shaderUniformTexelBufferArrayDynamicIndexing),
     shaderStorageTexelBufferArrayDynamicIndexing(in_struct->shaderStorageTexelBufferArrayDynamicIndexing),
@@ -20031,15 +21916,16 @@ safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::safe_VkPhysicalDeviceDescrip
     descriptorBindingVariableDescriptorCount(in_struct->descriptorBindingVariableDescriptorCount),
     runtimeDescriptorArray(in_struct->runtimeDescriptorArray)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT()
+safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(const safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderInputAttachmentArrayDynamicIndexing = src.shaderInputAttachmentArrayDynamicIndexing;
     shaderUniformTexelBufferArrayDynamicIndexing = src.shaderUniformTexelBufferArrayDynamicIndexing;
     shaderStorageTexelBufferArrayDynamicIndexing = src.shaderStorageTexelBufferArrayDynamicIndexing;
@@ -20060,15 +21946,17 @@ safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::safe_VkPhysicalDeviceDescrip
     descriptorBindingPartiallyBound = src.descriptorBindingPartiallyBound;
     descriptorBindingVariableDescriptorCount = src.descriptorBindingVariableDescriptorCount;
     runtimeDescriptorArray = src.runtimeDescriptorArray;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT& safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::operator=(const safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderInputAttachmentArrayDynamicIndexing = src.shaderInputAttachmentArrayDynamicIndexing;
     shaderUniformTexelBufferArrayDynamicIndexing = src.shaderUniformTexelBufferArrayDynamicIndexing;
     shaderStorageTexelBufferArrayDynamicIndexing = src.shaderStorageTexelBufferArrayDynamicIndexing;
@@ -20089,18 +21977,20 @@ safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT& safe_VkPhysicalDeviceDescrip
     descriptorBindingPartiallyBound = src.descriptorBindingPartiallyBound;
     descriptorBindingVariableDescriptorCount = src.descriptorBindingVariableDescriptorCount;
     runtimeDescriptorArray = src.runtimeDescriptorArray;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::~safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::initialize(const VkPhysicalDeviceDescriptorIndexingFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderInputAttachmentArrayDynamicIndexing = in_struct->shaderInputAttachmentArrayDynamicIndexing;
     shaderUniformTexelBufferArrayDynamicIndexing = in_struct->shaderUniformTexelBufferArrayDynamicIndexing;
     shaderStorageTexelBufferArrayDynamicIndexing = in_struct->shaderStorageTexelBufferArrayDynamicIndexing;
@@ -20121,12 +22011,12 @@ void safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::initialize(const VkPhys
     descriptorBindingPartiallyBound = in_struct->descriptorBindingPartiallyBound;
     descriptorBindingVariableDescriptorCount = in_struct->descriptorBindingVariableDescriptorCount;
     runtimeDescriptorArray = in_struct->runtimeDescriptorArray;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::initialize(const safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderInputAttachmentArrayDynamicIndexing = src->shaderInputAttachmentArrayDynamicIndexing;
     shaderUniformTexelBufferArrayDynamicIndexing = src->shaderUniformTexelBufferArrayDynamicIndexing;
     shaderStorageTexelBufferArrayDynamicIndexing = src->shaderStorageTexelBufferArrayDynamicIndexing;
@@ -20147,11 +22037,11 @@ void safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT::initialize(const safe_V
     descriptorBindingPartiallyBound = src->descriptorBindingPartiallyBound;
     descriptorBindingVariableDescriptorCount = src->descriptorBindingVariableDescriptorCount;
     runtimeDescriptorArray = src->runtimeDescriptorArray;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxUpdateAfterBindDescriptorsInAllPools(in_struct->maxUpdateAfterBindDescriptorsInAllPools),
     shaderUniformBufferArrayNonUniformIndexingNative(in_struct->shaderUniformBufferArrayNonUniformIndexingNative),
     shaderSampledImageArrayNonUniformIndexingNative(in_struct->shaderSampledImageArrayNonUniformIndexingNative),
@@ -20176,15 +22066,16 @@ safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::safe_VkPhysicalDeviceDescr
     maxDescriptorSetUpdateAfterBindStorageImages(in_struct->maxDescriptorSetUpdateAfterBindStorageImages),
     maxDescriptorSetUpdateAfterBindInputAttachments(in_struct->maxDescriptorSetUpdateAfterBindInputAttachments)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT()
+safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(const safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxUpdateAfterBindDescriptorsInAllPools = src.maxUpdateAfterBindDescriptorsInAllPools;
     shaderUniformBufferArrayNonUniformIndexingNative = src.shaderUniformBufferArrayNonUniformIndexingNative;
     shaderSampledImageArrayNonUniformIndexingNative = src.shaderSampledImageArrayNonUniformIndexingNative;
@@ -20208,15 +22099,17 @@ safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::safe_VkPhysicalDeviceDescr
     maxDescriptorSetUpdateAfterBindSampledImages = src.maxDescriptorSetUpdateAfterBindSampledImages;
     maxDescriptorSetUpdateAfterBindStorageImages = src.maxDescriptorSetUpdateAfterBindStorageImages;
     maxDescriptorSetUpdateAfterBindInputAttachments = src.maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT& safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::operator=(const safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxUpdateAfterBindDescriptorsInAllPools = src.maxUpdateAfterBindDescriptorsInAllPools;
     shaderUniformBufferArrayNonUniformIndexingNative = src.shaderUniformBufferArrayNonUniformIndexingNative;
     shaderSampledImageArrayNonUniformIndexingNative = src.shaderSampledImageArrayNonUniformIndexingNative;
@@ -20240,18 +22133,20 @@ safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT& safe_VkPhysicalDeviceDescr
     maxDescriptorSetUpdateAfterBindSampledImages = src.maxDescriptorSetUpdateAfterBindSampledImages;
     maxDescriptorSetUpdateAfterBindStorageImages = src.maxDescriptorSetUpdateAfterBindStorageImages;
     maxDescriptorSetUpdateAfterBindInputAttachments = src.maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::~safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::initialize(const VkPhysicalDeviceDescriptorIndexingPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxUpdateAfterBindDescriptorsInAllPools = in_struct->maxUpdateAfterBindDescriptorsInAllPools;
     shaderUniformBufferArrayNonUniformIndexingNative = in_struct->shaderUniformBufferArrayNonUniformIndexingNative;
     shaderSampledImageArrayNonUniformIndexingNative = in_struct->shaderSampledImageArrayNonUniformIndexingNative;
@@ -20275,12 +22170,12 @@ void safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::initialize(const VkPh
     maxDescriptorSetUpdateAfterBindSampledImages = in_struct->maxDescriptorSetUpdateAfterBindSampledImages;
     maxDescriptorSetUpdateAfterBindStorageImages = in_struct->maxDescriptorSetUpdateAfterBindStorageImages;
     maxDescriptorSetUpdateAfterBindInputAttachments = in_struct->maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::initialize(const safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxUpdateAfterBindDescriptorsInAllPools = src->maxUpdateAfterBindDescriptorsInAllPools;
     shaderUniformBufferArrayNonUniformIndexingNative = src->shaderUniformBufferArrayNonUniformIndexingNative;
     shaderSampledImageArrayNonUniformIndexingNative = src->shaderSampledImageArrayNonUniformIndexingNative;
@@ -20304,14 +22199,15 @@ void safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT::initialize(const safe
     maxDescriptorSetUpdateAfterBindSampledImages = src->maxDescriptorSetUpdateAfterBindSampledImages;
     maxDescriptorSetUpdateAfterBindStorageImages = src->maxDescriptorSetUpdateAfterBindStorageImages;
     maxDescriptorSetUpdateAfterBindInputAttachments = src->maxDescriptorSetUpdateAfterBindInputAttachments;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     descriptorSetCount(in_struct->descriptorSetCount),
     pDescriptorCounts(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDescriptorCounts) {
         pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount];
         memcpy ((void *)pDescriptorCounts, (void *)in_struct->pDescriptorCounts, sizeof(uint32_t)*in_struct->descriptorSetCount);
@@ -20319,15 +22215,16 @@ safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::safe_VkDescriptorSet
 }
 
 safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT() :
+    pNext(nullptr),
     pDescriptorCounts(nullptr)
 {}
 
 safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     descriptorSetCount = src.descriptorSetCount;
     pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDescriptorCounts) {
         pDescriptorCounts = new uint32_t[src.descriptorSetCount];
         memcpy ((void *)pDescriptorCounts, (void *)src.pDescriptorCounts, sizeof(uint32_t)*src.descriptorSetCount);
@@ -20340,11 +22237,13 @@ safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT& safe_VkDescriptorSet
 
     if (pDescriptorCounts)
         delete[] pDescriptorCounts;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     descriptorSetCount = src.descriptorSetCount;
     pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDescriptorCounts) {
         pDescriptorCounts = new uint32_t[src.descriptorSetCount];
         memcpy ((void *)pDescriptorCounts, (void *)src.pDescriptorCounts, sizeof(uint32_t)*src.descriptorSetCount);
@@ -20357,14 +22256,16 @@ safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::~safe_VkDescriptorSe
 {
     if (pDescriptorCounts)
         delete[] pDescriptorCounts;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::initialize(const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     descriptorSetCount = in_struct->descriptorSetCount;
     pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDescriptorCounts) {
         pDescriptorCounts = new uint32_t[in_struct->descriptorSetCount];
         memcpy ((void *)pDescriptorCounts, (void *)in_struct->pDescriptorCounts, sizeof(uint32_t)*in_struct->descriptorSetCount);
@@ -20374,9 +22275,9 @@ void safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::initialize(cons
 void safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::initialize(const safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     descriptorSetCount = src->descriptorSetCount;
     pDescriptorCounts = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDescriptorCounts) {
         pDescriptorCounts = new uint32_t[src->descriptorSetCount];
         memcpy ((void *)pDescriptorCounts, (void *)src->pDescriptorCounts, sizeof(uint32_t)*src->descriptorSetCount);
@@ -20385,49 +22286,54 @@ void safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT::initialize(cons
 
 safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxVariableDescriptorCount(in_struct->maxVariableDescriptorCount)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT()
+safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxVariableDescriptorCount = src.maxVariableDescriptorCount;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT& safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::operator=(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxVariableDescriptorCount = src.maxVariableDescriptorCount;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::~safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::initialize(const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxVariableDescriptorCount = in_struct->maxVariableDescriptorCount;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT::initialize(const safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxVariableDescriptorCount = src->maxVariableDescriptorCount;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkShadingRatePaletteNV::safe_VkShadingRatePaletteNV(const VkShadingRatePaletteNV* in_struct) :
@@ -20499,33 +22405,34 @@ void safe_VkShadingRatePaletteNV::initialize(const safe_VkShadingRatePaletteNV*
 
 safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shadingRateImageEnable(in_struct->shadingRateImageEnable),
     viewportCount(in_struct->viewportCount),
     pShadingRatePalettes(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (viewportCount && in_struct->pShadingRatePalettes) {
         pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
-        for (uint32_t i=0; i<viewportCount; ++i) {
+        for (uint32_t i = 0; i < viewportCount; ++i) {
             pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
         }
     }
 }
 
 safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV() :
+    pNext(nullptr),
     pShadingRatePalettes(nullptr)
 {}
 
 safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shadingRateImageEnable = src.shadingRateImageEnable;
     viewportCount = src.viewportCount;
     pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (viewportCount && src.pShadingRatePalettes) {
         pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
-        for (uint32_t i=0; i<viewportCount; ++i) {
+        for (uint32_t i = 0; i < viewportCount; ++i) {
             pShadingRatePalettes[i].initialize(&src.pShadingRatePalettes[i]);
         }
     }
@@ -20537,15 +22444,17 @@ safe_VkPipelineViewportShadingRateImageStateCreateInfoNV& safe_VkPipelineViewpor
 
     if (pShadingRatePalettes)
         delete[] pShadingRatePalettes;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shadingRateImageEnable = src.shadingRateImageEnable;
     viewportCount = src.viewportCount;
     pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (viewportCount && src.pShadingRatePalettes) {
         pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
-        for (uint32_t i=0; i<viewportCount; ++i) {
+        for (uint32_t i = 0; i < viewportCount; ++i) {
             pShadingRatePalettes[i].initialize(&src.pShadingRatePalettes[i]);
         }
     }
@@ -20557,18 +22466,20 @@ safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::~safe_VkPipelineViewpo
 {
     if (pShadingRatePalettes)
         delete[] pShadingRatePalettes;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(const VkPipelineViewportShadingRateImageStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shadingRateImageEnable = in_struct->shadingRateImageEnable;
     viewportCount = in_struct->viewportCount;
     pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (viewportCount && in_struct->pShadingRatePalettes) {
         pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
-        for (uint32_t i=0; i<viewportCount; ++i) {
+        for (uint32_t i = 0; i < viewportCount; ++i) {
             pShadingRatePalettes[i].initialize(&in_struct->pShadingRatePalettes[i]);
         }
     }
@@ -20577,13 +22488,13 @@ void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(const
 void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shadingRateImageEnable = src->shadingRateImageEnable;
     viewportCount = src->viewportCount;
     pShadingRatePalettes = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (viewportCount && src->pShadingRatePalettes) {
         pShadingRatePalettes = new safe_VkShadingRatePaletteNV[viewportCount];
-        for (uint32_t i=0; i<viewportCount; ++i) {
+        for (uint32_t i = 0; i < viewportCount; ++i) {
             pShadingRatePalettes[i].initialize(&src->pShadingRatePalettes[i]);
         }
     }
@@ -20591,111 +22502,121 @@ void safe_VkPipelineViewportShadingRateImageStateCreateInfoNV::initialize(const
 
 safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shadingRateImage(in_struct->shadingRateImage),
     shadingRateCoarseSampleOrder(in_struct->shadingRateCoarseSampleOrder)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV()
+safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShadingRateImageFeaturesNV::safe_VkPhysicalDeviceShadingRateImageFeaturesNV(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shadingRateImage = src.shadingRateImage;
     shadingRateCoarseSampleOrder = src.shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShadingRateImageFeaturesNV& safe_VkPhysicalDeviceShadingRateImageFeaturesNV::operator=(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shadingRateImage = src.shadingRateImage;
     shadingRateCoarseSampleOrder = src.shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShadingRateImageFeaturesNV::~safe_VkPhysicalDeviceShadingRateImageFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const VkPhysicalDeviceShadingRateImageFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shadingRateImage = in_struct->shadingRateImage;
     shadingRateCoarseSampleOrder = in_struct->shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShadingRateImageFeaturesNV::initialize(const safe_VkPhysicalDeviceShadingRateImageFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shadingRateImage = src->shadingRateImage;
     shadingRateCoarseSampleOrder = src->shadingRateCoarseSampleOrder;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shadingRateTexelSize(in_struct->shadingRateTexelSize),
     shadingRatePaletteSize(in_struct->shadingRatePaletteSize),
     shadingRateMaxCoarseSamples(in_struct->shadingRateMaxCoarseSamples)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV()
+safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShadingRateImagePropertiesNV::safe_VkPhysicalDeviceShadingRateImagePropertiesNV(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shadingRateTexelSize = src.shadingRateTexelSize;
     shadingRatePaletteSize = src.shadingRatePaletteSize;
     shadingRateMaxCoarseSamples = src.shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShadingRateImagePropertiesNV& safe_VkPhysicalDeviceShadingRateImagePropertiesNV::operator=(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shadingRateTexelSize = src.shadingRateTexelSize;
     shadingRatePaletteSize = src.shadingRatePaletteSize;
     shadingRateMaxCoarseSamples = src.shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShadingRateImagePropertiesNV::~safe_VkPhysicalDeviceShadingRateImagePropertiesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize(const VkPhysicalDeviceShadingRateImagePropertiesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shadingRateTexelSize = in_struct->shadingRateTexelSize;
     shadingRatePaletteSize = in_struct->shadingRatePaletteSize;
     shadingRateMaxCoarseSamples = in_struct->shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShadingRateImagePropertiesNV::initialize(const safe_VkPhysicalDeviceShadingRateImagePropertiesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shadingRateTexelSize = src->shadingRateTexelSize;
     shadingRatePaletteSize = src->shadingRatePaletteSize;
     shadingRateMaxCoarseSamples = src->shadingRateMaxCoarseSamples;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkCoarseSampleOrderCustomNV::safe_VkCoarseSampleOrderCustomNV(const VkCoarseSampleOrderCustomNV* in_struct) :
@@ -20777,33 +22698,34 @@ void safe_VkCoarseSampleOrderCustomNV::initialize(const safe_VkCoarseSampleOrder
 
 safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     sampleOrderType(in_struct->sampleOrderType),
     customSampleOrderCount(in_struct->customSampleOrderCount),
     pCustomSampleOrders(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (customSampleOrderCount && in_struct->pCustomSampleOrders) {
         pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
-        for (uint32_t i=0; i<customSampleOrderCount; ++i) {
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
             pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
         }
     }
 }
 
 safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV() :
+    pNext(nullptr),
     pCustomSampleOrders(nullptr)
 {}
 
 safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     sampleOrderType = src.sampleOrderType;
     customSampleOrderCount = src.customSampleOrderCount;
     pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (customSampleOrderCount && src.pCustomSampleOrders) {
         pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
-        for (uint32_t i=0; i<customSampleOrderCount; ++i) {
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
             pCustomSampleOrders[i].initialize(&src.pCustomSampleOrders[i]);
         }
     }
@@ -20815,15 +22737,17 @@ safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& safe_VkPipelineViewpo
 
     if (pCustomSampleOrders)
         delete[] pCustomSampleOrders;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     sampleOrderType = src.sampleOrderType;
     customSampleOrderCount = src.customSampleOrderCount;
     pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (customSampleOrderCount && src.pCustomSampleOrders) {
         pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
-        for (uint32_t i=0; i<customSampleOrderCount; ++i) {
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
             pCustomSampleOrders[i].initialize(&src.pCustomSampleOrders[i]);
         }
     }
@@ -20835,18 +22759,20 @@ safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::~safe_VkPipelineViewp
 {
     if (pCustomSampleOrders)
         delete[] pCustomSampleOrders;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     sampleOrderType = in_struct->sampleOrderType;
     customSampleOrderCount = in_struct->customSampleOrderCount;
     pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (customSampleOrderCount && in_struct->pCustomSampleOrders) {
         pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
-        for (uint32_t i=0; i<customSampleOrderCount; ++i) {
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
             pCustomSampleOrders[i].initialize(&in_struct->pCustomSampleOrders[i]);
         }
     }
@@ -20855,13 +22781,13 @@ void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(const
 void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     sampleOrderType = src->sampleOrderType;
     customSampleOrderCount = src->customSampleOrderCount;
     pCustomSampleOrders = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (customSampleOrderCount && src->pCustomSampleOrders) {
         pCustomSampleOrders = new safe_VkCoarseSampleOrderCustomNV[customSampleOrderCount];
-        for (uint32_t i=0; i<customSampleOrderCount; ++i) {
+        for (uint32_t i = 0; i < customSampleOrderCount; ++i) {
             pCustomSampleOrders[i].initialize(&src->pCustomSampleOrders[i]);
         }
     }
@@ -20869,74 +22795,78 @@ void safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV::initialize(const
 
 safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV(const VkRayTracingShaderGroupCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     type(in_struct->type),
     generalShader(in_struct->generalShader),
     closestHitShader(in_struct->closestHitShader),
     anyHitShader(in_struct->anyHitShader),
     intersectionShader(in_struct->intersectionShader)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV()
+safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkRayTracingShaderGroupCreateInfoNV::safe_VkRayTracingShaderGroupCreateInfoNV(const safe_VkRayTracingShaderGroupCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     generalShader = src.generalShader;
     closestHitShader = src.closestHitShader;
     anyHitShader = src.anyHitShader;
     intersectionShader = src.intersectionShader;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkRayTracingShaderGroupCreateInfoNV& safe_VkRayTracingShaderGroupCreateInfoNV::operator=(const safe_VkRayTracingShaderGroupCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     generalShader = src.generalShader;
     closestHitShader = src.closestHitShader;
     anyHitShader = src.anyHitShader;
     intersectionShader = src.intersectionShader;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkRayTracingShaderGroupCreateInfoNV::~safe_VkRayTracingShaderGroupCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const VkRayTracingShaderGroupCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     type = in_struct->type;
     generalShader = in_struct->generalShader;
     closestHitShader = in_struct->closestHitShader;
     anyHitShader = in_struct->anyHitShader;
     intersectionShader = in_struct->intersectionShader;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkRayTracingShaderGroupCreateInfoNV::initialize(const safe_VkRayTracingShaderGroupCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     type = src->type;
     generalShader = src->generalShader;
     closestHitShader = src->closestHitShader;
     anyHitShader = src->anyHitShader;
     intersectionShader = src->intersectionShader;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(const VkRayTracingPipelineCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     stageCount(in_struct->stageCount),
     pStages(nullptr),
@@ -20947,21 +22877,23 @@ safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(con
     basePipelineHandle(in_struct->basePipelineHandle),
     basePipelineIndex(in_struct->basePipelineIndex)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (stageCount && in_struct->pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&in_struct->pStages[i]);
         }
     }
     if (groupCount && in_struct->pGroups) {
         pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
-        for (uint32_t i=0; i<groupCount; ++i) {
+        for (uint32_t i = 0; i < groupCount; ++i) {
             pGroups[i].initialize(&in_struct->pGroups[i]);
         }
     }
 }
 
 safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV() :
+    pNext(nullptr),
     pStages(nullptr),
     pGroups(nullptr)
 {}
@@ -20969,7 +22901,6 @@ safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV() :
 safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(const safe_VkRayTracingPipelineCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stageCount = src.stageCount;
     pStages = nullptr;
@@ -20979,15 +22910,16 @@ safe_VkRayTracingPipelineCreateInfoNV::safe_VkRayTracingPipelineCreateInfoNV(con
     layout = src.layout;
     basePipelineHandle = src.basePipelineHandle;
     basePipelineIndex = src.basePipelineIndex;
+    pNext = SafePnextCopy(src.pNext);
     if (stageCount && src.pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&src.pStages[i]);
         }
     }
     if (groupCount && src.pGroups) {
         pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
-        for (uint32_t i=0; i<groupCount; ++i) {
+        for (uint32_t i = 0; i < groupCount; ++i) {
             pGroups[i].initialize(&src.pGroups[i]);
         }
     }
@@ -21001,9 +22933,10 @@ safe_VkRayTracingPipelineCreateInfoNV& safe_VkRayTracingPipelineCreateInfoNV::op
         delete[] pStages;
     if (pGroups)
         delete[] pGroups;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     stageCount = src.stageCount;
     pStages = nullptr;
@@ -21013,15 +22946,16 @@ safe_VkRayTracingPipelineCreateInfoNV& safe_VkRayTracingPipelineCreateInfoNV::op
     layout = src.layout;
     basePipelineHandle = src.basePipelineHandle;
     basePipelineIndex = src.basePipelineIndex;
+    pNext = SafePnextCopy(src.pNext);
     if (stageCount && src.pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&src.pStages[i]);
         }
     }
     if (groupCount && src.pGroups) {
         pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
-        for (uint32_t i=0; i<groupCount; ++i) {
+        for (uint32_t i = 0; i < groupCount; ++i) {
             pGroups[i].initialize(&src.pGroups[i]);
         }
     }
@@ -21035,12 +22969,13 @@ safe_VkRayTracingPipelineCreateInfoNV::~safe_VkRayTracingPipelineCreateInfoNV()
         delete[] pStages;
     if (pGroups)
         delete[] pGroups;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRayTracingPipelineCreateInfoNV::initialize(const VkRayTracingPipelineCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     stageCount = in_struct->stageCount;
     pStages = nullptr;
@@ -21050,15 +22985,16 @@ void safe_VkRayTracingPipelineCreateInfoNV::initialize(const VkRayTracingPipelin
     layout = in_struct->layout;
     basePipelineHandle = in_struct->basePipelineHandle;
     basePipelineIndex = in_struct->basePipelineIndex;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (stageCount && in_struct->pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&in_struct->pStages[i]);
         }
     }
     if (groupCount && in_struct->pGroups) {
         pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
-        for (uint32_t i=0; i<groupCount; ++i) {
+        for (uint32_t i = 0; i < groupCount; ++i) {
             pGroups[i].initialize(&in_struct->pGroups[i]);
         }
     }
@@ -21067,7 +23003,6 @@ void safe_VkRayTracingPipelineCreateInfoNV::initialize(const VkRayTracingPipelin
 void safe_VkRayTracingPipelineCreateInfoNV::initialize(const safe_VkRayTracingPipelineCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     stageCount = src->stageCount;
     pStages = nullptr;
@@ -21077,15 +23012,16 @@ void safe_VkRayTracingPipelineCreateInfoNV::initialize(const safe_VkRayTracingPi
     layout = src->layout;
     basePipelineHandle = src->basePipelineHandle;
     basePipelineIndex = src->basePipelineIndex;
+    pNext = SafePnextCopy(src->pNext);
     if (stageCount && src->pStages) {
         pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];
-        for (uint32_t i=0; i<stageCount; ++i) {
+        for (uint32_t i = 0; i < stageCount; ++i) {
             pStages[i].initialize(&src->pStages[i]);
         }
     }
     if (groupCount && src->pGroups) {
         pGroups = new safe_VkRayTracingShaderGroupCreateInfoNV[groupCount];
-        for (uint32_t i=0; i<groupCount; ++i) {
+        for (uint32_t i = 0; i < groupCount; ++i) {
             pGroups[i].initialize(&src->pGroups[i]);
         }
     }
@@ -21093,7 +23029,6 @@ void safe_VkRayTracingPipelineCreateInfoNV::initialize(const safe_VkRayTracingPi
 
 safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const VkGeometryTrianglesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     vertexData(in_struct->vertexData),
     vertexOffset(in_struct->vertexOffset),
     vertexCount(in_struct->vertexCount),
@@ -21106,15 +23041,16 @@ safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const VkGeometryTriangles
     transformData(in_struct->transformData),
     transformOffset(in_struct->transformOffset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV()
+safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const safe_VkGeometryTrianglesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     vertexData = src.vertexData;
     vertexOffset = src.vertexOffset;
     vertexCount = src.vertexCount;
@@ -21126,15 +23062,17 @@ safe_VkGeometryTrianglesNV::safe_VkGeometryTrianglesNV(const safe_VkGeometryTria
     indexType = src.indexType;
     transformData = src.transformData;
     transformOffset = src.transformOffset;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkGeometryTrianglesNV& safe_VkGeometryTrianglesNV::operator=(const safe_VkGeometryTrianglesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     vertexData = src.vertexData;
     vertexOffset = src.vertexOffset;
     vertexCount = src.vertexCount;
@@ -21146,18 +23084,20 @@ safe_VkGeometryTrianglesNV& safe_VkGeometryTrianglesNV::operator=(const safe_VkG
     indexType = src.indexType;
     transformData = src.transformData;
     transformOffset = src.transformOffset;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkGeometryTrianglesNV::~safe_VkGeometryTrianglesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkGeometryTrianglesNV::initialize(const VkGeometryTrianglesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     vertexData = in_struct->vertexData;
     vertexOffset = in_struct->vertexOffset;
     vertexCount = in_struct->vertexCount;
@@ -21169,12 +23109,12 @@ void safe_VkGeometryTrianglesNV::initialize(const VkGeometryTrianglesNV* in_stru
     indexType = in_struct->indexType;
     transformData = in_struct->transformData;
     transformOffset = in_struct->transformOffset;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkGeometryTrianglesNV::initialize(const safe_VkGeometryTrianglesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     vertexData = src->vertexData;
     vertexOffset = src->vertexOffset;
     vertexCount = src->vertexCount;
@@ -21186,160 +23126,172 @@ void safe_VkGeometryTrianglesNV::initialize(const safe_VkGeometryTrianglesNV* sr
     indexType = src->indexType;
     transformData = src->transformData;
     transformOffset = src->transformOffset;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const VkGeometryAABBNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     aabbData(in_struct->aabbData),
     numAABBs(in_struct->numAABBs),
     stride(in_struct->stride),
     offset(in_struct->offset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkGeometryAABBNV::safe_VkGeometryAABBNV()
+safe_VkGeometryAABBNV::safe_VkGeometryAABBNV() :
+    pNext(nullptr)
 {}
 
 safe_VkGeometryAABBNV::safe_VkGeometryAABBNV(const safe_VkGeometryAABBNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     aabbData = src.aabbData;
     numAABBs = src.numAABBs;
     stride = src.stride;
     offset = src.offset;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkGeometryAABBNV& safe_VkGeometryAABBNV::operator=(const safe_VkGeometryAABBNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     aabbData = src.aabbData;
     numAABBs = src.numAABBs;
     stride = src.stride;
     offset = src.offset;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkGeometryAABBNV::~safe_VkGeometryAABBNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkGeometryAABBNV::initialize(const VkGeometryAABBNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     aabbData = in_struct->aabbData;
     numAABBs = in_struct->numAABBs;
     stride = in_struct->stride;
     offset = in_struct->offset;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkGeometryAABBNV::initialize(const safe_VkGeometryAABBNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     aabbData = src->aabbData;
     numAABBs = src->numAABBs;
     stride = src->stride;
     offset = src->offset;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkGeometryNV::safe_VkGeometryNV(const VkGeometryNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     geometryType(in_struct->geometryType),
     geometry(in_struct->geometry),
     flags(in_struct->flags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkGeometryNV::safe_VkGeometryNV()
+safe_VkGeometryNV::safe_VkGeometryNV() :
+    pNext(nullptr)
 {}
 
 safe_VkGeometryNV::safe_VkGeometryNV(const safe_VkGeometryNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     geometryType = src.geometryType;
     geometry = src.geometry;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkGeometryNV& safe_VkGeometryNV::operator=(const safe_VkGeometryNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     geometryType = src.geometryType;
     geometry = src.geometry;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkGeometryNV::~safe_VkGeometryNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkGeometryNV::initialize(const VkGeometryNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     geometryType = in_struct->geometryType;
     geometry = in_struct->geometry;
     flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkGeometryNV::initialize(const safe_VkGeometryNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     geometryType = src->geometryType;
     geometry = src->geometry;
     flags = src->flags;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     type(in_struct->type),
     flags(in_struct->flags),
     instanceCount(in_struct->instanceCount),
     geometryCount(in_struct->geometryCount),
     pGeometries(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (geometryCount && in_struct->pGeometries) {
         pGeometries = new safe_VkGeometryNV[geometryCount];
-        for (uint32_t i=0; i<geometryCount; ++i) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
             pGeometries[i].initialize(&in_struct->pGeometries[i]);
         }
     }
 }
 
 safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV() :
+    pNext(nullptr),
     pGeometries(nullptr)
 {}
 
 safe_VkAccelerationStructureInfoNV::safe_VkAccelerationStructureInfoNV(const safe_VkAccelerationStructureInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     flags = src.flags;
     instanceCount = src.instanceCount;
     geometryCount = src.geometryCount;
     pGeometries = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (geometryCount && src.pGeometries) {
         pGeometries = new safe_VkGeometryNV[geometryCount];
-        for (uint32_t i=0; i<geometryCount; ++i) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
             pGeometries[i].initialize(&src.pGeometries[i]);
         }
     }
@@ -21351,17 +23303,19 @@ safe_VkAccelerationStructureInfoNV& safe_VkAccelerationStructureInfoNV::operator
 
     if (pGeometries)
         delete[] pGeometries;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     flags = src.flags;
     instanceCount = src.instanceCount;
     geometryCount = src.geometryCount;
     pGeometries = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (geometryCount && src.pGeometries) {
         pGeometries = new safe_VkGeometryNV[geometryCount];
-        for (uint32_t i=0; i<geometryCount; ++i) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
             pGeometries[i].initialize(&src.pGeometries[i]);
         }
     }
@@ -21373,20 +23327,22 @@ safe_VkAccelerationStructureInfoNV::~safe_VkAccelerationStructureInfoNV()
 {
     if (pGeometries)
         delete[] pGeometries;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAccelerationStructureInfoNV::initialize(const VkAccelerationStructureInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     type = in_struct->type;
     flags = in_struct->flags;
     instanceCount = in_struct->instanceCount;
     geometryCount = in_struct->geometryCount;
     pGeometries = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (geometryCount && in_struct->pGeometries) {
         pGeometries = new safe_VkGeometryNV[geometryCount];
-        for (uint32_t i=0; i<geometryCount; ++i) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
             pGeometries[i].initialize(&in_struct->pGeometries[i]);
         }
     }
@@ -21395,15 +23351,15 @@ void safe_VkAccelerationStructureInfoNV::initialize(const VkAccelerationStructur
 void safe_VkAccelerationStructureInfoNV::initialize(const safe_VkAccelerationStructureInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     type = src->type;
     flags = src->flags;
     instanceCount = src->instanceCount;
     geometryCount = src->geometryCount;
     pGeometries = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (geometryCount && src->pGeometries) {
         pGeometries = new safe_VkGeometryNV[geometryCount];
-        for (uint32_t i=0; i<geometryCount; ++i) {
+        for (uint32_t i = 0; i < geometryCount; ++i) {
             pGeometries[i].initialize(&src->pGeometries[i]);
         }
     }
@@ -21411,65 +23367,70 @@ void safe_VkAccelerationStructureInfoNV::initialize(const safe_VkAccelerationStr
 
 safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV(const VkAccelerationStructureCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     compactedSize(in_struct->compactedSize),
     info(&in_struct->info)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV()
+safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkAccelerationStructureCreateInfoNV::safe_VkAccelerationStructureCreateInfoNV(const safe_VkAccelerationStructureCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     compactedSize = src.compactedSize;
     info.initialize(&src.info);
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAccelerationStructureCreateInfoNV& safe_VkAccelerationStructureCreateInfoNV::operator=(const safe_VkAccelerationStructureCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     compactedSize = src.compactedSize;
     info.initialize(&src.info);
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAccelerationStructureCreateInfoNV::~safe_VkAccelerationStructureCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAccelerationStructureCreateInfoNV::initialize(const VkAccelerationStructureCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     compactedSize = in_struct->compactedSize;
     info.initialize(&in_struct->info);
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAccelerationStructureCreateInfoNV::initialize(const safe_VkAccelerationStructureCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     compactedSize = src->compactedSize;
     info.initialize(&src->info);
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV(const VkBindAccelerationStructureMemoryInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     accelerationStructure(in_struct->accelerationStructure),
     memory(in_struct->memory),
     memoryOffset(in_struct->memoryOffset),
     deviceIndexCount(in_struct->deviceIndexCount),
     pDeviceIndices(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceIndices) {
         pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
@@ -21477,18 +23438,19 @@ safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMe
 }
 
 safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV() :
+    pNext(nullptr),
     pDeviceIndices(nullptr)
 {}
 
 safe_VkBindAccelerationStructureMemoryInfoNV::safe_VkBindAccelerationStructureMemoryInfoNV(const safe_VkBindAccelerationStructureMemoryInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     accelerationStructure = src.accelerationStructure;
     memory = src.memory;
     memoryOffset = src.memoryOffset;
     deviceIndexCount = src.deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceIndices) {
         pDeviceIndices = new uint32_t[src.deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
@@ -21501,14 +23463,16 @@ safe_VkBindAccelerationStructureMemoryInfoNV& safe_VkBindAccelerationStructureMe
 
     if (pDeviceIndices)
         delete[] pDeviceIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     accelerationStructure = src.accelerationStructure;
     memory = src.memory;
     memoryOffset = src.memoryOffset;
     deviceIndexCount = src.deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pDeviceIndices) {
         pDeviceIndices = new uint32_t[src.deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src.pDeviceIndices, sizeof(uint32_t)*src.deviceIndexCount);
@@ -21521,17 +23485,19 @@ safe_VkBindAccelerationStructureMemoryInfoNV::~safe_VkBindAccelerationStructureM
 {
     if (pDeviceIndices)
         delete[] pDeviceIndices;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const VkBindAccelerationStructureMemoryInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     accelerationStructure = in_struct->accelerationStructure;
     memory = in_struct->memory;
     memoryOffset = in_struct->memoryOffset;
     deviceIndexCount = in_struct->deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pDeviceIndices) {
         pDeviceIndices = new uint32_t[in_struct->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)in_struct->pDeviceIndices, sizeof(uint32_t)*in_struct->deviceIndexCount);
@@ -21541,12 +23507,12 @@ void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const VkBindAccele
 void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const safe_VkBindAccelerationStructureMemoryInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     accelerationStructure = src->accelerationStructure;
     memory = src->memory;
     memoryOffset = src->memoryOffset;
     deviceIndexCount = src->deviceIndexCount;
     pDeviceIndices = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pDeviceIndices) {
         pDeviceIndices = new uint32_t[src->deviceIndexCount];
         memcpy ((void *)pDeviceIndices, (void *)src->pDeviceIndices, sizeof(uint32_t)*src->deviceIndexCount);
@@ -21555,31 +23521,32 @@ void safe_VkBindAccelerationStructureMemoryInfoNV::initialize(const safe_VkBindA
 
 safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV(const VkWriteDescriptorSetAccelerationStructureNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     accelerationStructureCount(in_struct->accelerationStructureCount),
     pAccelerationStructures(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (accelerationStructureCount && in_struct->pAccelerationStructures) {
         pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
-        for (uint32_t i=0; i<accelerationStructureCount; ++i) {
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
             pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
         }
     }
 }
 
 safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV() :
+    pNext(nullptr),
     pAccelerationStructures(nullptr)
 {}
 
 safe_VkWriteDescriptorSetAccelerationStructureNV::safe_VkWriteDescriptorSetAccelerationStructureNV(const safe_VkWriteDescriptorSetAccelerationStructureNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     accelerationStructureCount = src.accelerationStructureCount;
     pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (accelerationStructureCount && src.pAccelerationStructures) {
         pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
-        for (uint32_t i=0; i<accelerationStructureCount; ++i) {
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
             pAccelerationStructures[i] = src.pAccelerationStructures[i];
         }
     }
@@ -21591,14 +23558,16 @@ safe_VkWriteDescriptorSetAccelerationStructureNV& safe_VkWriteDescriptorSetAccel
 
     if (pAccelerationStructures)
         delete[] pAccelerationStructures;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     accelerationStructureCount = src.accelerationStructureCount;
     pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (accelerationStructureCount && src.pAccelerationStructures) {
         pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
-        for (uint32_t i=0; i<accelerationStructureCount; ++i) {
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
             pAccelerationStructures[i] = src.pAccelerationStructures[i];
         }
     }
@@ -21610,17 +23579,19 @@ safe_VkWriteDescriptorSetAccelerationStructureNV::~safe_VkWriteDescriptorSetAcce
 {
     if (pAccelerationStructures)
         delete[] pAccelerationStructures;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const VkWriteDescriptorSetAccelerationStructureNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     accelerationStructureCount = in_struct->accelerationStructureCount;
     pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (accelerationStructureCount && in_struct->pAccelerationStructures) {
         pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
-        for (uint32_t i=0; i<accelerationStructureCount; ++i) {
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
             pAccelerationStructures[i] = in_struct->pAccelerationStructures[i];
         }
     }
@@ -21629,12 +23600,12 @@ void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const VkWriteD
 void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const safe_VkWriteDescriptorSetAccelerationStructureNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     accelerationStructureCount = src->accelerationStructureCount;
     pAccelerationStructures = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (accelerationStructureCount && src->pAccelerationStructures) {
         pAccelerationStructures = new VkAccelerationStructureNV[accelerationStructureCount];
-        for (uint32_t i=0; i<accelerationStructureCount; ++i) {
+        for (uint32_t i = 0; i < accelerationStructureCount; ++i) {
             pAccelerationStructures[i] = src->pAccelerationStructures[i];
         }
     }
@@ -21642,59 +23613,63 @@ void safe_VkWriteDescriptorSetAccelerationStructureNV::initialize(const safe_VkW
 
 safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     type(in_struct->type),
     accelerationStructure(in_struct->accelerationStructure)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV()
+safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkAccelerationStructureMemoryRequirementsInfoNV::safe_VkAccelerationStructureMemoryRequirementsInfoNV(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     accelerationStructure = src.accelerationStructure;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkAccelerationStructureMemoryRequirementsInfoNV& safe_VkAccelerationStructureMemoryRequirementsInfoNV::operator=(const safe_VkAccelerationStructureMemoryRequirementsInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     accelerationStructure = src.accelerationStructure;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkAccelerationStructureMemoryRequirementsInfoNV::~safe_VkAccelerationStructureMemoryRequirementsInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize(const VkAccelerationStructureMemoryRequirementsInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     type = in_struct->type;
     accelerationStructure = in_struct->accelerationStructure;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkAccelerationStructureMemoryRequirementsInfoNV::initialize(const safe_VkAccelerationStructureMemoryRequirementsInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     type = src->type;
     accelerationStructure = src->accelerationStructure;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderGroupHandleSize(in_struct->shaderGroupHandleSize),
     maxRecursionDepth(in_struct->maxRecursionDepth),
     maxShaderGroupStride(in_struct->maxShaderGroupStride),
@@ -21704,15 +23679,16 @@ safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingProp
     maxTriangleCount(in_struct->maxTriangleCount),
     maxDescriptorSetAccelerationStructures(in_struct->maxDescriptorSetAccelerationStructures)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV()
+safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingPropertiesNV(const safe_VkPhysicalDeviceRayTracingPropertiesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderGroupHandleSize = src.shaderGroupHandleSize;
     maxRecursionDepth = src.maxRecursionDepth;
     maxShaderGroupStride = src.maxShaderGroupStride;
@@ -21721,15 +23697,17 @@ safe_VkPhysicalDeviceRayTracingPropertiesNV::safe_VkPhysicalDeviceRayTracingProp
     maxInstanceCount = src.maxInstanceCount;
     maxTriangleCount = src.maxTriangleCount;
     maxDescriptorSetAccelerationStructures = src.maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceRayTracingPropertiesNV& safe_VkPhysicalDeviceRayTracingPropertiesNV::operator=(const safe_VkPhysicalDeviceRayTracingPropertiesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderGroupHandleSize = src.shaderGroupHandleSize;
     maxRecursionDepth = src.maxRecursionDepth;
     maxShaderGroupStride = src.maxShaderGroupStride;
@@ -21738,18 +23716,20 @@ safe_VkPhysicalDeviceRayTracingPropertiesNV& safe_VkPhysicalDeviceRayTracingProp
     maxInstanceCount = src.maxInstanceCount;
     maxTriangleCount = src.maxTriangleCount;
     maxDescriptorSetAccelerationStructures = src.maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceRayTracingPropertiesNV::~safe_VkPhysicalDeviceRayTracingPropertiesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const VkPhysicalDeviceRayTracingPropertiesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderGroupHandleSize = in_struct->shaderGroupHandleSize;
     maxRecursionDepth = in_struct->maxRecursionDepth;
     maxShaderGroupStride = in_struct->maxShaderGroupStride;
@@ -21758,12 +23738,12 @@ void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const VkPhysicalDev
     maxInstanceCount = in_struct->maxInstanceCount;
     maxTriangleCount = in_struct->maxTriangleCount;
     maxDescriptorSetAccelerationStructures = in_struct->maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const safe_VkPhysicalDeviceRayTracingPropertiesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderGroupHandleSize = src->shaderGroupHandleSize;
     maxRecursionDepth = src->maxRecursionDepth;
     maxShaderGroupStride = src->maxShaderGroupStride;
@@ -21772,444 +23752,542 @@ void safe_VkPhysicalDeviceRayTracingPropertiesNV::initialize(const safe_VkPhysic
     maxInstanceCount = src->maxInstanceCount;
     maxTriangleCount = src->maxTriangleCount;
     maxDescriptorSetAccelerationStructures = src->maxDescriptorSetAccelerationStructures;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     representativeFragmentTest(in_struct->representativeFragmentTest)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV()
+safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     representativeFragmentTest = src.representativeFragmentTest;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::operator=(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     representativeFragmentTest = src.representativeFragmentTest;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::~safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     representativeFragmentTest = in_struct->representativeFragmentTest;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV::initialize(const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     representativeFragmentTest = src->representativeFragmentTest;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     representativeFragmentTestEnable(in_struct->representativeFragmentTestEnable)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV()
+safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     representativeFragmentTestEnable = src.representativeFragmentTestEnable;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::operator=(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     representativeFragmentTestEnable = src.representativeFragmentTestEnable;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::~safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     representativeFragmentTestEnable = in_struct->representativeFragmentTestEnable;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV::initialize(const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     representativeFragmentTestEnable = src->representativeFragmentTestEnable;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     imageViewType(in_struct->imageViewType)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT()
+safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     imageViewType = src.imageViewType;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::operator=(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     imageViewType = src.imageViewType;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::~safe_VkPhysicalDeviceImageViewImageFormatInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const VkPhysicalDeviceImageViewImageFormatInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     imageViewType = in_struct->imageViewType;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceImageViewImageFormatInfoEXT::initialize(const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     imageViewType = src->imageViewType;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     filterCubic(in_struct->filterCubic),
     filterCubicMinmax(in_struct->filterCubicMinmax)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT()
+safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkFilterCubicImageViewImageFormatPropertiesEXT::safe_VkFilterCubicImageViewImageFormatPropertiesEXT(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     filterCubic = src.filterCubic;
     filterCubicMinmax = src.filterCubicMinmax;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkFilterCubicImageViewImageFormatPropertiesEXT& safe_VkFilterCubicImageViewImageFormatPropertiesEXT::operator=(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     filterCubic = src.filterCubic;
     filterCubicMinmax = src.filterCubicMinmax;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkFilterCubicImageViewImageFormatPropertiesEXT::~safe_VkFilterCubicImageViewImageFormatPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize(const VkFilterCubicImageViewImageFormatPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     filterCubic = in_struct->filterCubic;
     filterCubicMinmax = in_struct->filterCubicMinmax;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkFilterCubicImageViewImageFormatPropertiesEXT::initialize(const safe_VkFilterCubicImageViewImageFormatPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     filterCubic = src->filterCubic;
     filterCubicMinmax = src->filterCubicMinmax;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     globalPriority(in_struct->globalPriority)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::safe_VkDeviceQueueGlobalPriorityCreateInfoEXT()
+safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::safe_VkDeviceQueueGlobalPriorityCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     globalPriority = src.globalPriority;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::operator=(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     globalPriority = src.globalPriority;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::~safe_VkDeviceQueueGlobalPriorityCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::initialize(const VkDeviceQueueGlobalPriorityCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     globalPriority = in_struct->globalPriority;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceQueueGlobalPriorityCreateInfoEXT::initialize(const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     globalPriority = src->globalPriority;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT(const VkImportMemoryHostPointerInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     handleType(in_struct->handleType),
     pHostPointer(in_struct->pHostPointer)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT()
+safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT() :
+    pNext(nullptr),
+    pHostPointer(nullptr)
 {}
 
 safe_VkImportMemoryHostPointerInfoEXT::safe_VkImportMemoryHostPointerInfoEXT(const safe_VkImportMemoryHostPointerInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     pHostPointer = src.pHostPointer;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImportMemoryHostPointerInfoEXT& safe_VkImportMemoryHostPointerInfoEXT::operator=(const safe_VkImportMemoryHostPointerInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     handleType = src.handleType;
     pHostPointer = src.pHostPointer;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImportMemoryHostPointerInfoEXT::~safe_VkImportMemoryHostPointerInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImportMemoryHostPointerInfoEXT::initialize(const VkImportMemoryHostPointerInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     handleType = in_struct->handleType;
     pHostPointer = in_struct->pHostPointer;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImportMemoryHostPointerInfoEXT::initialize(const safe_VkImportMemoryHostPointerInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     handleType = src->handleType;
     pHostPointer = src->pHostPointer;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT(const VkMemoryHostPointerPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memoryTypeBits(in_struct->memoryTypeBits)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT()
+safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryHostPointerPropertiesEXT::safe_VkMemoryHostPointerPropertiesEXT(const safe_VkMemoryHostPointerPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryHostPointerPropertiesEXT& safe_VkMemoryHostPointerPropertiesEXT::operator=(const safe_VkMemoryHostPointerPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memoryTypeBits = src.memoryTypeBits;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryHostPointerPropertiesEXT::~safe_VkMemoryHostPointerPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryHostPointerPropertiesEXT::initialize(const VkMemoryHostPointerPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memoryTypeBits = in_struct->memoryTypeBits;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryHostPointerPropertiesEXT::initialize(const safe_VkMemoryHostPointerPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memoryTypeBits = src->memoryTypeBits;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     minImportedHostPointerAlignment(in_struct->minImportedHostPointerAlignment)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT()
+safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     minImportedHostPointerAlignment = src.minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::operator=(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     minImportedHostPointerAlignment = src.minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::~safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     minImportedHostPointerAlignment = in_struct->minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT::initialize(const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     minImportedHostPointerAlignment = src->minImportedHostPointerAlignment;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct) :
+    sType(in_struct->sType),
+    compilerControlFlags(in_struct->compilerControlFlags)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD() :
+    pNext(nullptr)
+{}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::safe_VkPipelineCompilerControlCreateInfoAMD(const safe_VkPipelineCompilerControlCreateInfoAMD& src)
+{
+    sType = src.sType;
+    compilerControlFlags = src.compilerControlFlags;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD& safe_VkPipelineCompilerControlCreateInfoAMD::operator=(const safe_VkPipelineCompilerControlCreateInfoAMD& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    compilerControlFlags = src.compilerControlFlags;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineCompilerControlCreateInfoAMD::~safe_VkPipelineCompilerControlCreateInfoAMD()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct)
+{
+    sType = in_struct->sType;
+    compilerControlFlags = in_struct->compilerControlFlags;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPipelineCompilerControlCreateInfoAMD::initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* src)
+{
+    sType = src->sType;
+    compilerControlFlags = src->compilerControlFlags;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkCalibratedTimestampInfoEXT::safe_VkCalibratedTimestampInfoEXT(const VkCalibratedTimestampInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     timeDomain(in_struct->timeDomain)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCalibratedTimestampInfoEXT::safe_VkCalibratedTimestampInfoEXT()
+safe_VkCalibratedTimestampInfoEXT::safe_VkCalibratedTimestampInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkCalibratedTimestampInfoEXT::safe_VkCalibratedTimestampInfoEXT(const safe_VkCalibratedTimestampInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     timeDomain = src.timeDomain;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCalibratedTimestampInfoEXT& safe_VkCalibratedTimestampInfoEXT::operator=(const safe_VkCalibratedTimestampInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     timeDomain = src.timeDomain;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCalibratedTimestampInfoEXT::~safe_VkCalibratedTimestampInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCalibratedTimestampInfoEXT::initialize(const VkCalibratedTimestampInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     timeDomain = in_struct->timeDomain;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCalibratedTimestampInfoEXT::initialize(const safe_VkCalibratedTimestampInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     timeDomain = src->timeDomain;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderEngineCount(in_struct->shaderEngineCount),
     shaderArraysPerEngineCount(in_struct->shaderArraysPerEngineCount),
     computeUnitsPerShaderArray(in_struct->computeUnitsPerShaderArray),
@@ -22225,15 +24303,16 @@ safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePro
     maxVgprAllocation(in_struct->maxVgprAllocation),
     vgprAllocationGranularity(in_struct->vgprAllocationGranularity)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD()
+safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePropertiesAMD(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderEngineCount = src.shaderEngineCount;
     shaderArraysPerEngineCount = src.shaderArraysPerEngineCount;
     computeUnitsPerShaderArray = src.computeUnitsPerShaderArray;
@@ -22248,15 +24327,17 @@ safe_VkPhysicalDeviceShaderCorePropertiesAMD::safe_VkPhysicalDeviceShaderCorePro
     minVgprAllocation = src.minVgprAllocation;
     maxVgprAllocation = src.maxVgprAllocation;
     vgprAllocationGranularity = src.vgprAllocationGranularity;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShaderCorePropertiesAMD& safe_VkPhysicalDeviceShaderCorePropertiesAMD::operator=(const safe_VkPhysicalDeviceShaderCorePropertiesAMD& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderEngineCount = src.shaderEngineCount;
     shaderArraysPerEngineCount = src.shaderArraysPerEngineCount;
     computeUnitsPerShaderArray = src.computeUnitsPerShaderArray;
@@ -22271,18 +24352,20 @@ safe_VkPhysicalDeviceShaderCorePropertiesAMD& safe_VkPhysicalDeviceShaderCorePro
     minVgprAllocation = src.minVgprAllocation;
     maxVgprAllocation = src.maxVgprAllocation;
     vgprAllocationGranularity = src.vgprAllocationGranularity;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShaderCorePropertiesAMD::~safe_VkPhysicalDeviceShaderCorePropertiesAMD()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const VkPhysicalDeviceShaderCorePropertiesAMD* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderEngineCount = in_struct->shaderEngineCount;
     shaderArraysPerEngineCount = in_struct->shaderArraysPerEngineCount;
     computeUnitsPerShaderArray = in_struct->computeUnitsPerShaderArray;
@@ -22297,12 +24380,12 @@ void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const VkPhysicalDe
     minVgprAllocation = in_struct->minVgprAllocation;
     maxVgprAllocation = in_struct->maxVgprAllocation;
     vgprAllocationGranularity = in_struct->vgprAllocationGranularity;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const safe_VkPhysicalDeviceShaderCorePropertiesAMD* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderEngineCount = src->shaderEngineCount;
     shaderArraysPerEngineCount = src->shaderArraysPerEngineCount;
     computeUnitsPerShaderArray = src->computeUnitsPerShaderArray;
@@ -22317,108 +24400,119 @@ void safe_VkPhysicalDeviceShaderCorePropertiesAMD::initialize(const safe_VkPhysi
     minVgprAllocation = src->minVgprAllocation;
     maxVgprAllocation = src->maxVgprAllocation;
     vgprAllocationGranularity = src->vgprAllocationGranularity;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     overallocationBehavior(in_struct->overallocationBehavior)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD()
+safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD() :
+    pNext(nullptr)
 {}
 
 safe_VkDeviceMemoryOverallocationCreateInfoAMD::safe_VkDeviceMemoryOverallocationCreateInfoAMD(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     overallocationBehavior = src.overallocationBehavior;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDeviceMemoryOverallocationCreateInfoAMD& safe_VkDeviceMemoryOverallocationCreateInfoAMD::operator=(const safe_VkDeviceMemoryOverallocationCreateInfoAMD& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     overallocationBehavior = src.overallocationBehavior;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDeviceMemoryOverallocationCreateInfoAMD::~safe_VkDeviceMemoryOverallocationCreateInfoAMD()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const VkDeviceMemoryOverallocationCreateInfoAMD* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     overallocationBehavior = in_struct->overallocationBehavior;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDeviceMemoryOverallocationCreateInfoAMD::initialize(const safe_VkDeviceMemoryOverallocationCreateInfoAMD* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     overallocationBehavior = src->overallocationBehavior;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxVertexAttribDivisor(in_struct->maxVertexAttribDivisor)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT()
+safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxVertexAttribDivisor = src.maxVertexAttribDivisor;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxVertexAttribDivisor = src.maxVertexAttribDivisor;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::~safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxVertexAttribDivisor = in_struct->maxVertexAttribDivisor;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT::initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxVertexAttribDivisor = src->maxVertexAttribDivisor;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     vertexBindingDivisorCount(in_struct->vertexBindingDivisorCount),
     pVertexBindingDivisors(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pVertexBindingDivisors) {
         pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[in_struct->vertexBindingDivisorCount];
         memcpy ((void *)pVertexBindingDivisors, (void *)in_struct->pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*in_struct->vertexBindingDivisorCount);
@@ -22426,15 +24520,16 @@ safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::safe_VkPipelineVertexInputD
 }
 
 safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::safe_VkPipelineVertexInputDivisorStateCreateInfoEXT() :
+    pNext(nullptr),
     pVertexBindingDivisors(nullptr)
 {}
 
 safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     vertexBindingDivisorCount = src.vertexBindingDivisorCount;
     pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pVertexBindingDivisors) {
         pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[src.vertexBindingDivisorCount];
         memcpy ((void *)pVertexBindingDivisors, (void *)src.pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*src.vertexBindingDivisorCount);
@@ -22447,11 +24542,13 @@ safe_VkPipelineVertexInputDivisorStateCreateInfoEXT& safe_VkPipelineVertexInputD
 
     if (pVertexBindingDivisors)
         delete[] pVertexBindingDivisors;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     vertexBindingDivisorCount = src.vertexBindingDivisorCount;
     pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pVertexBindingDivisors) {
         pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[src.vertexBindingDivisorCount];
         memcpy ((void *)pVertexBindingDivisors, (void *)src.pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*src.vertexBindingDivisorCount);
@@ -22464,14 +24561,16 @@ safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::~safe_VkPipelineVertexInput
 {
     if (pVertexBindingDivisors)
         delete[] pVertexBindingDivisors;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::initialize(const VkPipelineVertexInputDivisorStateCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     vertexBindingDivisorCount = in_struct->vertexBindingDivisorCount;
     pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pVertexBindingDivisors) {
         pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[in_struct->vertexBindingDivisorCount];
         memcpy ((void *)pVertexBindingDivisors, (void *)in_struct->pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*in_struct->vertexBindingDivisorCount);
@@ -22481,9 +24580,9 @@ void safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::initialize(const VkPip
 void safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::initialize(const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     vertexBindingDivisorCount = src->vertexBindingDivisorCount;
     pVertexBindingDivisors = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pVertexBindingDivisors) {
         pVertexBindingDivisors = new VkVertexInputBindingDivisorDescriptionEXT[src->vertexBindingDivisorCount];
         memcpy ((void *)pVertexBindingDivisors, (void *)src->pVertexBindingDivisors, sizeof(VkVertexInputBindingDivisorDescriptionEXT)*src->vertexBindingDivisorCount);
@@ -22492,114 +24591,124 @@ void safe_VkPipelineVertexInputDivisorStateCreateInfoEXT::initialize(const safe_
 
 safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     vertexAttributeInstanceRateDivisor(in_struct->vertexAttributeInstanceRateDivisor),
     vertexAttributeInstanceRateZeroDivisor(in_struct->vertexAttributeInstanceRateZeroDivisor)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT()
+safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     vertexAttributeInstanceRateDivisor = src.vertexAttributeInstanceRateDivisor;
     vertexAttributeInstanceRateZeroDivisor = src.vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::operator=(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     vertexAttributeInstanceRateDivisor = src.vertexAttributeInstanceRateDivisor;
     vertexAttributeInstanceRateZeroDivisor = src.vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::~safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::initialize(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     vertexAttributeInstanceRateDivisor = in_struct->vertexAttributeInstanceRateDivisor;
     vertexAttributeInstanceRateZeroDivisor = in_struct->vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT::initialize(const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     vertexAttributeInstanceRateDivisor = src->vertexAttributeInstanceRateDivisor;
     vertexAttributeInstanceRateZeroDivisor = src->vertexAttributeInstanceRateZeroDivisor;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_GGP
 
 
 safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const VkPresentFrameTokenGGP* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     frameToken(in_struct->frameToken)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP()
+safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP() :
+    pNext(nullptr)
 {}
 
 safe_VkPresentFrameTokenGGP::safe_VkPresentFrameTokenGGP(const safe_VkPresentFrameTokenGGP& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     frameToken = src.frameToken;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPresentFrameTokenGGP& safe_VkPresentFrameTokenGGP::operator=(const safe_VkPresentFrameTokenGGP& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     frameToken = src.frameToken;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPresentFrameTokenGGP::~safe_VkPresentFrameTokenGGP()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPresentFrameTokenGGP::initialize(const VkPresentFrameTokenGGP* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     frameToken = in_struct->frameToken;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPresentFrameTokenGGP::initialize(const safe_VkPresentFrameTokenGGP* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     frameToken = src->frameToken;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_GGP
 
 
 safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCreateInfoEXT(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pPipelineCreationFeedback(nullptr),
     pipelineStageCreationFeedbackCount(in_struct->pipelineStageCreationFeedbackCount),
     pPipelineStageCreationFeedbacks(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPipelineCreationFeedback) {
         pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*in_struct->pPipelineCreationFeedback);
     }
@@ -22610,6 +24719,7 @@ safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCre
 }
 
 safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCreateInfoEXT() :
+    pNext(nullptr),
     pPipelineCreationFeedback(nullptr),
     pPipelineStageCreationFeedbacks(nullptr)
 {}
@@ -22617,10 +24727,10 @@ safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCre
 safe_VkPipelineCreationFeedbackCreateInfoEXT::safe_VkPipelineCreationFeedbackCreateInfoEXT(const safe_VkPipelineCreationFeedbackCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pPipelineCreationFeedback = nullptr;
     pipelineStageCreationFeedbackCount = src.pipelineStageCreationFeedbackCount;
     pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPipelineCreationFeedback) {
         pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*src.pPipelineCreationFeedback);
     }
@@ -22638,12 +24748,14 @@ safe_VkPipelineCreationFeedbackCreateInfoEXT& safe_VkPipelineCreationFeedbackCre
         delete pPipelineCreationFeedback;
     if (pPipelineStageCreationFeedbacks)
         delete[] pPipelineStageCreationFeedbacks;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pPipelineCreationFeedback = nullptr;
     pipelineStageCreationFeedbackCount = src.pipelineStageCreationFeedbackCount;
     pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pPipelineCreationFeedback) {
         pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*src.pPipelineCreationFeedback);
     }
@@ -22661,15 +24773,17 @@ safe_VkPipelineCreationFeedbackCreateInfoEXT::~safe_VkPipelineCreationFeedbackCr
         delete pPipelineCreationFeedback;
     if (pPipelineStageCreationFeedbacks)
         delete[] pPipelineStageCreationFeedbacks;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineCreationFeedbackCreateInfoEXT::initialize(const VkPipelineCreationFeedbackCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pPipelineCreationFeedback = nullptr;
     pipelineStageCreationFeedbackCount = in_struct->pipelineStageCreationFeedbackCount;
     pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pPipelineCreationFeedback) {
         pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*in_struct->pPipelineCreationFeedback);
     }
@@ -22682,10 +24796,10 @@ void safe_VkPipelineCreationFeedbackCreateInfoEXT::initialize(const VkPipelineCr
 void safe_VkPipelineCreationFeedbackCreateInfoEXT::initialize(const safe_VkPipelineCreationFeedbackCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pPipelineCreationFeedback = nullptr;
     pipelineStageCreationFeedbackCount = src->pipelineStageCreationFeedbackCount;
     pPipelineStageCreationFeedbacks = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pPipelineCreationFeedback) {
         pPipelineCreationFeedback = new VkPipelineCreationFeedbackEXT(*src->pPipelineCreationFeedback);
     }
@@ -22697,111 +24811,120 @@ void safe_VkPipelineCreationFeedbackCreateInfoEXT::initialize(const safe_VkPipel
 
 safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     computeDerivativeGroupQuads(in_struct->computeDerivativeGroupQuads),
     computeDerivativeGroupLinear(in_struct->computeDerivativeGroupLinear)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV()
+safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     computeDerivativeGroupQuads = src.computeDerivativeGroupQuads;
     computeDerivativeGroupLinear = src.computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::operator=(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     computeDerivativeGroupQuads = src.computeDerivativeGroupQuads;
     computeDerivativeGroupLinear = src.computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::~safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     computeDerivativeGroupQuads = in_struct->computeDerivativeGroupQuads;
     computeDerivativeGroupLinear = in_struct->computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV::initialize(const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     computeDerivativeGroupQuads = src->computeDerivativeGroupQuads;
     computeDerivativeGroupLinear = src->computeDerivativeGroupLinear;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     taskShader(in_struct->taskShader),
     meshShader(in_struct->meshShader)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV()
+safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMeshShaderFeaturesNV::safe_VkPhysicalDeviceMeshShaderFeaturesNV(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     taskShader = src.taskShader;
     meshShader = src.meshShader;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceMeshShaderFeaturesNV& safe_VkPhysicalDeviceMeshShaderFeaturesNV::operator=(const safe_VkPhysicalDeviceMeshShaderFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     taskShader = src.taskShader;
     meshShader = src.meshShader;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceMeshShaderFeaturesNV::~safe_VkPhysicalDeviceMeshShaderFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const VkPhysicalDeviceMeshShaderFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     taskShader = in_struct->taskShader;
     meshShader = in_struct->meshShader;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceMeshShaderFeaturesNV::initialize(const safe_VkPhysicalDeviceMeshShaderFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     taskShader = src->taskShader;
     meshShader = src->meshShader;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     maxDrawMeshTasksCount(in_struct->maxDrawMeshTasksCount),
     maxTaskWorkGroupInvocations(in_struct->maxTaskWorkGroupInvocations),
     maxTaskTotalMemorySize(in_struct->maxTaskTotalMemorySize),
@@ -22814,21 +24937,22 @@ safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderProp
     meshOutputPerVertexGranularity(in_struct->meshOutputPerVertexGranularity),
     meshOutputPerPrimitiveGranularity(in_struct->meshOutputPerPrimitiveGranularity)
 {
-    for (uint32_t i=0; i<3; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < 3; ++i) {
         maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
     }
-    for (uint32_t i=0; i<3; ++i) {
+    for (uint32_t i = 0; i < 3; ++i) {
         maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
     }
 }
 
-safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV()
+safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderPropertiesNV(const safe_VkPhysicalDeviceMeshShaderPropertiesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     maxDrawMeshTasksCount = src.maxDrawMeshTasksCount;
     maxTaskWorkGroupInvocations = src.maxTaskWorkGroupInvocations;
     maxTaskTotalMemorySize = src.maxTaskTotalMemorySize;
@@ -22840,10 +24964,11 @@ safe_VkPhysicalDeviceMeshShaderPropertiesNV::safe_VkPhysicalDeviceMeshShaderProp
     maxMeshMultiviewViewCount = src.maxMeshMultiviewViewCount;
     meshOutputPerVertexGranularity = src.meshOutputPerVertexGranularity;
     meshOutputPerPrimitiveGranularity = src.meshOutputPerPrimitiveGranularity;
-    for (uint32_t i=0; i<3; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < 3; ++i) {
         maxTaskWorkGroupSize[i] = src.maxTaskWorkGroupSize[i];
     }
-    for (uint32_t i=0; i<3; ++i) {
+    for (uint32_t i = 0; i < 3; ++i) {
         maxMeshWorkGroupSize[i] = src.maxMeshWorkGroupSize[i];
     }
 }
@@ -22852,9 +24977,10 @@ safe_VkPhysicalDeviceMeshShaderPropertiesNV& safe_VkPhysicalDeviceMeshShaderProp
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     maxDrawMeshTasksCount = src.maxDrawMeshTasksCount;
     maxTaskWorkGroupInvocations = src.maxTaskWorkGroupInvocations;
     maxTaskTotalMemorySize = src.maxTaskTotalMemorySize;
@@ -22866,10 +24992,11 @@ safe_VkPhysicalDeviceMeshShaderPropertiesNV& safe_VkPhysicalDeviceMeshShaderProp
     maxMeshMultiviewViewCount = src.maxMeshMultiviewViewCount;
     meshOutputPerVertexGranularity = src.meshOutputPerVertexGranularity;
     meshOutputPerPrimitiveGranularity = src.meshOutputPerPrimitiveGranularity;
-    for (uint32_t i=0; i<3; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < 3; ++i) {
         maxTaskWorkGroupSize[i] = src.maxTaskWorkGroupSize[i];
     }
-    for (uint32_t i=0; i<3; ++i) {
+    for (uint32_t i = 0; i < 3; ++i) {
         maxMeshWorkGroupSize[i] = src.maxMeshWorkGroupSize[i];
     }
 
@@ -22878,12 +25005,13 @@ safe_VkPhysicalDeviceMeshShaderPropertiesNV& safe_VkPhysicalDeviceMeshShaderProp
 
 safe_VkPhysicalDeviceMeshShaderPropertiesNV::~safe_VkPhysicalDeviceMeshShaderPropertiesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const VkPhysicalDeviceMeshShaderPropertiesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     maxDrawMeshTasksCount = in_struct->maxDrawMeshTasksCount;
     maxTaskWorkGroupInvocations = in_struct->maxTaskWorkGroupInvocations;
     maxTaskTotalMemorySize = in_struct->maxTaskTotalMemorySize;
@@ -22895,10 +25023,11 @@ void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const VkPhysicalDev
     maxMeshMultiviewViewCount = in_struct->maxMeshMultiviewViewCount;
     meshOutputPerVertexGranularity = in_struct->meshOutputPerVertexGranularity;
     meshOutputPerPrimitiveGranularity = in_struct->meshOutputPerPrimitiveGranularity;
-    for (uint32_t i=0; i<3; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < 3; ++i) {
         maxTaskWorkGroupSize[i] = in_struct->maxTaskWorkGroupSize[i];
     }
-    for (uint32_t i=0; i<3; ++i) {
+    for (uint32_t i = 0; i < 3; ++i) {
         maxMeshWorkGroupSize[i] = in_struct->maxMeshWorkGroupSize[i];
     }
 }
@@ -22906,7 +25035,6 @@ void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const VkPhysicalDev
 void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const safe_VkPhysicalDeviceMeshShaderPropertiesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     maxDrawMeshTasksCount = src->maxDrawMeshTasksCount;
     maxTaskWorkGroupInvocations = src->maxTaskWorkGroupInvocations;
     maxTaskTotalMemorySize = src->maxTaskTotalMemorySize;
@@ -22918,114 +25046,125 @@ void safe_VkPhysicalDeviceMeshShaderPropertiesNV::initialize(const safe_VkPhysic
     maxMeshMultiviewViewCount = src->maxMeshMultiviewViewCount;
     meshOutputPerVertexGranularity = src->meshOutputPerVertexGranularity;
     meshOutputPerPrimitiveGranularity = src->meshOutputPerPrimitiveGranularity;
-    for (uint32_t i=0; i<3; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < 3; ++i) {
         maxTaskWorkGroupSize[i] = src->maxTaskWorkGroupSize[i];
     }
-    for (uint32_t i=0; i<3; ++i) {
+    for (uint32_t i = 0; i < 3; ++i) {
         maxMeshWorkGroupSize[i] = src->maxMeshWorkGroupSize[i];
     }
 }
 
 safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fragmentShaderBarycentric(in_struct->fragmentShaderBarycentric)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV()
+safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fragmentShaderBarycentric = src.fragmentShaderBarycentric;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::operator=(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fragmentShaderBarycentric = src.fragmentShaderBarycentric;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::~safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::initialize(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fragmentShaderBarycentric = in_struct->fragmentShaderBarycentric;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV::initialize(const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fragmentShaderBarycentric = src->fragmentShaderBarycentric;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     imageFootprint(in_struct->imageFootprint)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV()
+safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     imageFootprint = src.imageFootprint;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::operator=(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     imageFootprint = src.imageFootprint;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::~safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize(const VkPhysicalDeviceShaderImageFootprintFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     imageFootprint = in_struct->imageFootprint;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV::initialize(const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     imageFootprint = src->imageFootprint;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     exclusiveScissorCount(in_struct->exclusiveScissorCount),
     pExclusiveScissors(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pExclusiveScissors) {
         pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount];
         memcpy ((void *)pExclusiveScissors, (void *)in_struct->pExclusiveScissors, sizeof(VkRect2D)*in_struct->exclusiveScissorCount);
@@ -23033,15 +25172,16 @@ safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewpor
 }
 
 safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV() :
+    pNext(nullptr),
     pExclusiveScissors(nullptr)
 {}
 
 safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     exclusiveScissorCount = src.exclusiveScissorCount;
     pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pExclusiveScissors) {
         pExclusiveScissors = new VkRect2D[src.exclusiveScissorCount];
         memcpy ((void *)pExclusiveScissors, (void *)src.pExclusiveScissors, sizeof(VkRect2D)*src.exclusiveScissorCount);
@@ -23054,11 +25194,13 @@ safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV& safe_VkPipelineViewpor
 
     if (pExclusiveScissors)
         delete[] pExclusiveScissors;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     exclusiveScissorCount = src.exclusiveScissorCount;
     pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pExclusiveScissors) {
         pExclusiveScissors = new VkRect2D[src.exclusiveScissorCount];
         memcpy ((void *)pExclusiveScissors, (void *)src.pExclusiveScissors, sizeof(VkRect2D)*src.exclusiveScissorCount);
@@ -23071,14 +25213,16 @@ safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::~safe_VkPipelineViewpo
 {
     if (pExclusiveScissors)
         delete[] pExclusiveScissors;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(const VkPipelineViewportExclusiveScissorStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     exclusiveScissorCount = in_struct->exclusiveScissorCount;
     pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pExclusiveScissors) {
         pExclusiveScissors = new VkRect2D[in_struct->exclusiveScissorCount];
         memcpy ((void *)pExclusiveScissors, (void *)in_struct->pExclusiveScissors, sizeof(VkRect2D)*in_struct->exclusiveScissorCount);
@@ -23088,9 +25232,9 @@ void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(const
 void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     exclusiveScissorCount = src->exclusiveScissorCount;
     pExclusiveScissors = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pExclusiveScissors) {
         pExclusiveScissors = new VkRect2D[src->exclusiveScissorCount];
         memcpy ((void *)pExclusiveScissors, (void *)src->pExclusiveScissors, sizeof(VkRect2D)*src->exclusiveScissorCount);
@@ -23099,207 +25243,229 @@ void safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV::initialize(const
 
 safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     exclusiveScissor(in_struct->exclusiveScissor)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV()
+safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     exclusiveScissor = src.exclusiveScissor;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::operator=(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     exclusiveScissor = src.exclusiveScissor;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::~safe_VkPhysicalDeviceExclusiveScissorFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const VkPhysicalDeviceExclusiveScissorFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     exclusiveScissor = in_struct->exclusiveScissor;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceExclusiveScissorFeaturesNV::initialize(const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     exclusiveScissor = src->exclusiveScissor;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV(const VkQueueFamilyCheckpointPropertiesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     checkpointExecutionStageMask(in_struct->checkpointExecutionStageMask)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV()
+safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkQueueFamilyCheckpointPropertiesNV::safe_VkQueueFamilyCheckpointPropertiesNV(const safe_VkQueueFamilyCheckpointPropertiesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     checkpointExecutionStageMask = src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkQueueFamilyCheckpointPropertiesNV& safe_VkQueueFamilyCheckpointPropertiesNV::operator=(const safe_VkQueueFamilyCheckpointPropertiesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     checkpointExecutionStageMask = src.checkpointExecutionStageMask;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkQueueFamilyCheckpointPropertiesNV::~safe_VkQueueFamilyCheckpointPropertiesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const VkQueueFamilyCheckpointPropertiesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     checkpointExecutionStageMask = in_struct->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkQueueFamilyCheckpointPropertiesNV::initialize(const safe_VkQueueFamilyCheckpointPropertiesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     checkpointExecutionStageMask = src->checkpointExecutionStageMask;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const VkCheckpointDataNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     stage(in_struct->stage),
     pCheckpointMarker(in_struct->pCheckpointMarker)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCheckpointDataNV::safe_VkCheckpointDataNV()
+safe_VkCheckpointDataNV::safe_VkCheckpointDataNV() :
+    pNext(nullptr),
+    pCheckpointMarker(nullptr)
 {}
 
 safe_VkCheckpointDataNV::safe_VkCheckpointDataNV(const safe_VkCheckpointDataNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     stage = src.stage;
     pCheckpointMarker = src.pCheckpointMarker;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCheckpointDataNV& safe_VkCheckpointDataNV::operator=(const safe_VkCheckpointDataNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     stage = src.stage;
     pCheckpointMarker = src.pCheckpointMarker;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCheckpointDataNV::~safe_VkCheckpointDataNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCheckpointDataNV::initialize(const VkCheckpointDataNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     stage = in_struct->stage;
     pCheckpointMarker = in_struct->pCheckpointMarker;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCheckpointDataNV::initialize(const safe_VkCheckpointDataNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     stage = src->stage;
     pCheckpointMarker = src->pCheckpointMarker;
+    pNext = SafePnextCopy(src->pNext);
 }
 
-safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL(const VkPhysicalDeviceShaderIntegerFunctions2INTEL* in_struct) :
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderIntegerFunctions2(in_struct->shaderIntegerFunctions2)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL()
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL() :
+    pNext(nullptr)
 {}
 
-safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL(const safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL& src)
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderIntegerFunctions2 = src.shaderIntegerFunctions2;
+    pNext = SafePnextCopy(src.pNext);
 }
 
-safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL& safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL::operator=(const safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL& src)
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::operator=(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderIntegerFunctions2 = src.shaderIntegerFunctions2;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
-safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL::~safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL()
+safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
-void safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL::initialize(const VkPhysicalDeviceShaderIntegerFunctions2INTEL* in_struct)
+void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderIntegerFunctions2 = in_struct->shaderIntegerFunctions2;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-void safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL::initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL* src)
+void safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL::initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderIntegerFunctions2 = src->shaderIntegerFunctions2;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const VkPerformanceValueDataINTEL* in_struct) :
     value32(in_struct->value32),
     value64(in_struct->value64),
     valueFloat(in_struct->valueFloat),
-    valueBool(in_struct->valueBool),
-    valueString(in_struct->valueString)
+    valueBool(in_struct->valueBool)
 {
+    valueString = SafeStringCopy(in_struct->valueString);
 }
 
-safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL()
+safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL() :
+    valueString(nullptr)
 {}
 
 safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const safe_VkPerformanceValueDataINTEL& src)
@@ -23308,25 +25474,27 @@ safe_VkPerformanceValueDataINTEL::safe_VkPerformanceValueDataINTEL(const safe_Vk
     value64 = src.value64;
     valueFloat = src.valueFloat;
     valueBool = src.valueBool;
-    valueString = src.valueString;
+    valueString = SafeStringCopy(src.valueString);
 }
 
 safe_VkPerformanceValueDataINTEL& safe_VkPerformanceValueDataINTEL::operator=(const safe_VkPerformanceValueDataINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (valueString) delete [] valueString;
 
     value32 = src.value32;
     value64 = src.value64;
     valueFloat = src.valueFloat;
     valueBool = src.valueBool;
-    valueString = src.valueString;
+    valueString = SafeStringCopy(src.valueString);
 
     return *this;
 }
 
 safe_VkPerformanceValueDataINTEL::~safe_VkPerformanceValueDataINTEL()
 {
+    if (valueString) delete [] valueString;
 }
 
 void safe_VkPerformanceValueDataINTEL::initialize(const VkPerformanceValueDataINTEL* in_struct)
@@ -23335,7 +25503,7 @@ void safe_VkPerformanceValueDataINTEL::initialize(const VkPerformanceValueDataIN
     value64 = in_struct->value64;
     valueFloat = in_struct->valueFloat;
     valueBool = in_struct->valueBool;
-    valueString = in_struct->valueString;
+    valueString = SafeStringCopy(in_struct->valueString);
 }
 
 void safe_VkPerformanceValueDataINTEL::initialize(const safe_VkPerformanceValueDataINTEL* src)
@@ -23344,509 +25512,560 @@ void safe_VkPerformanceValueDataINTEL::initialize(const safe_VkPerformanceValueD
     value64 = src->value64;
     valueFloat = src->valueFloat;
     valueBool = src->valueBool;
-    valueString = src->valueString;
+    valueString = SafeStringCopy(src->valueString);
 }
 
 safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL(const VkInitializePerformanceApiInfoINTEL* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pUserData(in_struct->pUserData)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL()
+safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL() :
+    pNext(nullptr),
+    pUserData(nullptr)
 {}
 
 safe_VkInitializePerformanceApiInfoINTEL::safe_VkInitializePerformanceApiInfoINTEL(const safe_VkInitializePerformanceApiInfoINTEL& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pUserData = src.pUserData;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkInitializePerformanceApiInfoINTEL& safe_VkInitializePerformanceApiInfoINTEL::operator=(const safe_VkInitializePerformanceApiInfoINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pUserData = src.pUserData;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkInitializePerformanceApiInfoINTEL::~safe_VkInitializePerformanceApiInfoINTEL()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkInitializePerformanceApiInfoINTEL::initialize(const VkInitializePerformanceApiInfoINTEL* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pUserData = in_struct->pUserData;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkInitializePerformanceApiInfoINTEL::initialize(const safe_VkInitializePerformanceApiInfoINTEL* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pUserData = src->pUserData;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkQueryPoolCreateInfoINTEL::safe_VkQueryPoolCreateInfoINTEL(const VkQueryPoolCreateInfoINTEL* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     performanceCountersSampling(in_struct->performanceCountersSampling)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkQueryPoolCreateInfoINTEL::safe_VkQueryPoolCreateInfoINTEL()
+safe_VkQueryPoolCreateInfoINTEL::safe_VkQueryPoolCreateInfoINTEL() :
+    pNext(nullptr)
 {}
 
 safe_VkQueryPoolCreateInfoINTEL::safe_VkQueryPoolCreateInfoINTEL(const safe_VkQueryPoolCreateInfoINTEL& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     performanceCountersSampling = src.performanceCountersSampling;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkQueryPoolCreateInfoINTEL& safe_VkQueryPoolCreateInfoINTEL::operator=(const safe_VkQueryPoolCreateInfoINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     performanceCountersSampling = src.performanceCountersSampling;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkQueryPoolCreateInfoINTEL::~safe_VkQueryPoolCreateInfoINTEL()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkQueryPoolCreateInfoINTEL::initialize(const VkQueryPoolCreateInfoINTEL* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     performanceCountersSampling = in_struct->performanceCountersSampling;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkQueryPoolCreateInfoINTEL::initialize(const safe_VkQueryPoolCreateInfoINTEL* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     performanceCountersSampling = src->performanceCountersSampling;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const VkPerformanceMarkerInfoINTEL* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     marker(in_struct->marker)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL()
+safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL() :
+    pNext(nullptr)
 {}
 
 safe_VkPerformanceMarkerInfoINTEL::safe_VkPerformanceMarkerInfoINTEL(const safe_VkPerformanceMarkerInfoINTEL& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     marker = src.marker;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPerformanceMarkerInfoINTEL& safe_VkPerformanceMarkerInfoINTEL::operator=(const safe_VkPerformanceMarkerInfoINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     marker = src.marker;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPerformanceMarkerInfoINTEL::~safe_VkPerformanceMarkerInfoINTEL()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPerformanceMarkerInfoINTEL::initialize(const VkPerformanceMarkerInfoINTEL* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     marker = in_struct->marker;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPerformanceMarkerInfoINTEL::initialize(const safe_VkPerformanceMarkerInfoINTEL* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     marker = src->marker;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL(const VkPerformanceStreamMarkerInfoINTEL* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     marker(in_struct->marker)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL()
+safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL() :
+    pNext(nullptr)
 {}
 
 safe_VkPerformanceStreamMarkerInfoINTEL::safe_VkPerformanceStreamMarkerInfoINTEL(const safe_VkPerformanceStreamMarkerInfoINTEL& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     marker = src.marker;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPerformanceStreamMarkerInfoINTEL& safe_VkPerformanceStreamMarkerInfoINTEL::operator=(const safe_VkPerformanceStreamMarkerInfoINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     marker = src.marker;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPerformanceStreamMarkerInfoINTEL::~safe_VkPerformanceStreamMarkerInfoINTEL()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const VkPerformanceStreamMarkerInfoINTEL* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     marker = in_struct->marker;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPerformanceStreamMarkerInfoINTEL::initialize(const safe_VkPerformanceStreamMarkerInfoINTEL* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     marker = src->marker;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const VkPerformanceOverrideInfoINTEL* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     type(in_struct->type),
     enable(in_struct->enable),
     parameter(in_struct->parameter)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL()
+safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL() :
+    pNext(nullptr)
 {}
 
 safe_VkPerformanceOverrideInfoINTEL::safe_VkPerformanceOverrideInfoINTEL(const safe_VkPerformanceOverrideInfoINTEL& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     enable = src.enable;
     parameter = src.parameter;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPerformanceOverrideInfoINTEL& safe_VkPerformanceOverrideInfoINTEL::operator=(const safe_VkPerformanceOverrideInfoINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
     enable = src.enable;
     parameter = src.parameter;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPerformanceOverrideInfoINTEL::~safe_VkPerformanceOverrideInfoINTEL()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPerformanceOverrideInfoINTEL::initialize(const VkPerformanceOverrideInfoINTEL* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     type = in_struct->type;
     enable = in_struct->enable;
     parameter = in_struct->parameter;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPerformanceOverrideInfoINTEL::initialize(const safe_VkPerformanceOverrideInfoINTEL* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     type = src->type;
     enable = src->enable;
     parameter = src->parameter;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     type(in_struct->type)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL()
+safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL() :
+    pNext(nullptr)
 {}
 
 safe_VkPerformanceConfigurationAcquireInfoINTEL::safe_VkPerformanceConfigurationAcquireInfoINTEL(const safe_VkPerformanceConfigurationAcquireInfoINTEL& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPerformanceConfigurationAcquireInfoINTEL& safe_VkPerformanceConfigurationAcquireInfoINTEL::operator=(const safe_VkPerformanceConfigurationAcquireInfoINTEL& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     type = src.type;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPerformanceConfigurationAcquireInfoINTEL::~safe_VkPerformanceConfigurationAcquireInfoINTEL()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const VkPerformanceConfigurationAcquireInfoINTEL* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     type = in_struct->type;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPerformanceConfigurationAcquireInfoINTEL::initialize(const safe_VkPerformanceConfigurationAcquireInfoINTEL* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     type = src->type;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     pciDomain(in_struct->pciDomain),
     pciBus(in_struct->pciBus),
     pciDevice(in_struct->pciDevice),
     pciFunction(in_struct->pciFunction)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT()
+safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     pciDomain = src.pciDomain;
     pciBus = src.pciBus;
     pciDevice = src.pciDevice;
     pciFunction = src.pciFunction;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::operator=(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     pciDomain = src.pciDomain;
     pciBus = src.pciBus;
     pciDevice = src.pciDevice;
     pciFunction = src.pciFunction;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::~safe_VkPhysicalDevicePCIBusInfoPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const VkPhysicalDevicePCIBusInfoPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     pciDomain = in_struct->pciDomain;
     pciBus = in_struct->pciBus;
     pciDevice = in_struct->pciDevice;
     pciFunction = in_struct->pciFunction;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDevicePCIBusInfoPropertiesEXT::initialize(const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     pciDomain = src->pciDomain;
     pciBus = src->pciBus;
     pciDevice = src->pciDevice;
     pciFunction = src->pciFunction;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     localDimmingSupport(in_struct->localDimmingSupport)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD()
+safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD() :
+    pNext(nullptr)
 {}
 
 safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     localDimmingSupport = src.localDimmingSupport;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::operator=(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     localDimmingSupport = src.localDimmingSupport;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::~safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const VkDisplayNativeHdrSurfaceCapabilitiesAMD* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     localDimmingSupport = in_struct->localDimmingSupport;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD::initialize(const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     localDimmingSupport = src->localDimmingSupport;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     localDimmingEnable(in_struct->localDimmingEnable)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD()
+safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD() :
+    pNext(nullptr)
 {}
 
 safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     localDimmingEnable = src.localDimmingEnable;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::operator=(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     localDimmingEnable = src.localDimmingEnable;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::~safe_VkSwapchainDisplayNativeHdrCreateInfoAMD()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const VkSwapchainDisplayNativeHdrCreateInfoAMD* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     localDimmingEnable = in_struct->localDimmingEnable;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSwapchainDisplayNativeHdrCreateInfoAMD::initialize(const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     localDimmingEnable = src->localDimmingEnable;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_FUCHSIA
 
 
 safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     imagePipeHandle(in_struct->imagePipeHandle)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA()
+safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA() :
+    pNext(nullptr)
 {}
 
 safe_VkImagePipeSurfaceCreateInfoFUCHSIA::safe_VkImagePipeSurfaceCreateInfoFUCHSIA(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     imagePipeHandle = src.imagePipeHandle;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImagePipeSurfaceCreateInfoFUCHSIA& safe_VkImagePipeSurfaceCreateInfoFUCHSIA::operator=(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     imagePipeHandle = src.imagePipeHandle;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImagePipeSurfaceCreateInfoFUCHSIA::~safe_VkImagePipeSurfaceCreateInfoFUCHSIA()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const VkImagePipeSurfaceCreateInfoFUCHSIA* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     imagePipeHandle = in_struct->imagePipeHandle;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const safe_VkImagePipeSurfaceCreateInfoFUCHSIA* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     imagePipeHandle = src->imagePipeHandle;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_FUCHSIA
 
@@ -23855,25 +26074,26 @@ void safe_VkImagePipeSurfaceCreateInfoFUCHSIA::initialize(const safe_VkImagePipe
 
 safe_VkMetalSurfaceCreateInfoEXT::safe_VkMetalSurfaceCreateInfoEXT(const VkMetalSurfaceCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     pLayer(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pLayer) {
         pLayer = new CAMetalLayer(*in_struct->pLayer);
     }
 }
 
 safe_VkMetalSurfaceCreateInfoEXT::safe_VkMetalSurfaceCreateInfoEXT() :
+    pNext(nullptr),
     pLayer(nullptr)
 {}
 
 safe_VkMetalSurfaceCreateInfoEXT::safe_VkMetalSurfaceCreateInfoEXT(const safe_VkMetalSurfaceCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pLayer = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pLayer) {
         pLayer = new CAMetalLayer(*src.pLayer);
     }
@@ -23885,11 +26105,13 @@ safe_VkMetalSurfaceCreateInfoEXT& safe_VkMetalSurfaceCreateInfoEXT::operator=(co
 
     if (pLayer)
         delete pLayer;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     pLayer = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pLayer) {
         pLayer = new CAMetalLayer(*src.pLayer);
     }
@@ -23901,14 +26123,16 @@ safe_VkMetalSurfaceCreateInfoEXT::~safe_VkMetalSurfaceCreateInfoEXT()
 {
     if (pLayer)
         delete pLayer;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMetalSurfaceCreateInfoEXT::initialize(const VkMetalSurfaceCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     pLayer = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pLayer) {
         pLayer = new CAMetalLayer(*in_struct->pLayer);
     }
@@ -23917,9 +26141,9 @@ void safe_VkMetalSurfaceCreateInfoEXT::initialize(const VkMetalSurfaceCreateInfo
 void safe_VkMetalSurfaceCreateInfoEXT::initialize(const safe_VkMetalSurfaceCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     pLayer = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pLayer) {
         pLayer = new CAMetalLayer(*src->pLayer);
     }
@@ -23929,235 +26153,541 @@ void safe_VkMetalSurfaceCreateInfoEXT::initialize(const safe_VkMetalSurfaceCreat
 
 safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fragmentDensityMap(in_struct->fragmentDensityMap),
     fragmentDensityMapDynamic(in_struct->fragmentDensityMapDynamic),
     fragmentDensityMapNonSubsampledImages(in_struct->fragmentDensityMapNonSubsampledImages)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT()
+safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fragmentDensityMap = src.fragmentDensityMap;
     fragmentDensityMapDynamic = src.fragmentDensityMapDynamic;
     fragmentDensityMapNonSubsampledImages = src.fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::operator=(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fragmentDensityMap = src.fragmentDensityMap;
     fragmentDensityMapDynamic = src.fragmentDensityMapDynamic;
     fragmentDensityMapNonSubsampledImages = src.fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::~safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fragmentDensityMap = in_struct->fragmentDensityMap;
     fragmentDensityMapDynamic = in_struct->fragmentDensityMapDynamic;
     fragmentDensityMapNonSubsampledImages = in_struct->fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT::initialize(const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fragmentDensityMap = src->fragmentDensityMap;
     fragmentDensityMapDynamic = src->fragmentDensityMapDynamic;
     fragmentDensityMapNonSubsampledImages = src->fragmentDensityMapNonSubsampledImages;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     minFragmentDensityTexelSize(in_struct->minFragmentDensityTexelSize),
     maxFragmentDensityTexelSize(in_struct->maxFragmentDensityTexelSize),
     fragmentDensityInvocations(in_struct->fragmentDensityInvocations)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT()
+safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     minFragmentDensityTexelSize = src.minFragmentDensityTexelSize;
     maxFragmentDensityTexelSize = src.maxFragmentDensityTexelSize;
     fragmentDensityInvocations = src.fragmentDensityInvocations;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::operator=(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     minFragmentDensityTexelSize = src.minFragmentDensityTexelSize;
     maxFragmentDensityTexelSize = src.maxFragmentDensityTexelSize;
     fragmentDensityInvocations = src.fragmentDensityInvocations;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::~safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     minFragmentDensityTexelSize = in_struct->minFragmentDensityTexelSize;
     maxFragmentDensityTexelSize = in_struct->maxFragmentDensityTexelSize;
     fragmentDensityInvocations = in_struct->fragmentDensityInvocations;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT::initialize(const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     minFragmentDensityTexelSize = src->minFragmentDensityTexelSize;
     maxFragmentDensityTexelSize = src->maxFragmentDensityTexelSize;
     fragmentDensityInvocations = src->fragmentDensityInvocations;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fragmentDensityMapAttachment(in_struct->fragmentDensityMapAttachment)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT()
+safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkRenderPassFragmentDensityMapCreateInfoEXT::safe_VkRenderPassFragmentDensityMapCreateInfoEXT(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fragmentDensityMapAttachment = src.fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkRenderPassFragmentDensityMapCreateInfoEXT& safe_VkRenderPassFragmentDensityMapCreateInfoEXT::operator=(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fragmentDensityMapAttachment = src.fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkRenderPassFragmentDensityMapCreateInfoEXT::~safe_VkRenderPassFragmentDensityMapCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const VkRenderPassFragmentDensityMapCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fragmentDensityMapAttachment = in_struct->fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkRenderPassFragmentDensityMapCreateInfoEXT::initialize(const safe_VkRenderPassFragmentDensityMapCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fragmentDensityMapAttachment = src->fragmentDensityMapAttachment;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT(const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     scalarBlockLayout(in_struct->scalarBlockLayout)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT()
+safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT(const safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     scalarBlockLayout = src.scalarBlockLayout;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT& safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::operator=(const safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     scalarBlockLayout = src.scalarBlockLayout;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::~safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::initialize(const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     scalarBlockLayout = in_struct->scalarBlockLayout;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT::initialize(const safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     scalarBlockLayout = src->scalarBlockLayout;
+    pNext = SafePnextCopy(src->pNext);
 }
 
-safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct) :
+safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct) :
+    sType(in_struct->sType),
+    subgroupSizeControl(in_struct->subgroupSizeControl),
+    computeFullSubgroups(in_struct->computeFullSubgroups)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& src)
+{
+    sType = src.sType;
+    subgroupSizeControl = src.subgroupSizeControl;
+    computeFullSubgroups = src.computeFullSubgroups;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::operator=(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    subgroupSizeControl = src.subgroupSizeControl;
+    computeFullSubgroups = src.computeFullSubgroups;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::~safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::initialize(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct)
+{
+    sType = in_struct->sType;
+    subgroupSizeControl = in_struct->subgroupSizeControl;
+    computeFullSubgroups = in_struct->computeFullSubgroups;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT::initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* src)
+{
+    sType = src->sType;
+    subgroupSizeControl = src->subgroupSizeControl;
+    computeFullSubgroups = src->computeFullSubgroups;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct) :
+    sType(in_struct->sType),
+    minSubgroupSize(in_struct->minSubgroupSize),
+    maxSubgroupSize(in_struct->maxSubgroupSize),
+    maxComputeWorkgroupSubgroups(in_struct->maxComputeWorkgroupSubgroups),
+    requiredSubgroupSizeStages(in_struct->requiredSubgroupSizeStages)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& src)
+{
+    sType = src.sType;
+    minSubgroupSize = src.minSubgroupSize;
+    maxSubgroupSize = src.maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = src.maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = src.requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::operator=(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    minSubgroupSize = src.minSubgroupSize;
+    maxSubgroupSize = src.maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = src.maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = src.requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::~safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::initialize(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct)
+{
+    sType = in_struct->sType;
+    minSubgroupSize = in_struct->minSubgroupSize;
+    maxSubgroupSize = in_struct->maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = in_struct->maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = in_struct->requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT::initialize(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* src)
+{
+    sType = src->sType;
+    minSubgroupSize = src->minSubgroupSize;
+    maxSubgroupSize = src->maxSubgroupSize;
+    maxComputeWorkgroupSubgroups = src->maxComputeWorkgroupSubgroups;
+    requiredSubgroupSizeStages = src->requiredSubgroupSizeStages;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct) :
+    sType(in_struct->sType),
+    requiredSubgroupSize(in_struct->requiredSubgroupSize)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& src)
+{
+    sType = src.sType;
+    requiredSubgroupSize = src.requiredSubgroupSize;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::operator=(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    requiredSubgroupSize = src.requiredSubgroupSize;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct)
+{
+    sType = in_struct->sType;
+    requiredSubgroupSize = in_struct->requiredSubgroupSize;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::initialize(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* src)
+{
+    sType = src->sType;
+    requiredSubgroupSize = src->requiredSubgroupSize;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct) :
+    sType(in_struct->sType),
+    shaderCoreFeatures(in_struct->shaderCoreFeatures),
+    activeComputeUnitCount(in_struct->activeComputeUnitCount)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::safe_VkPhysicalDeviceShaderCoreProperties2AMD(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& src)
+{
+    sType = src.sType;
+    shaderCoreFeatures = src.shaderCoreFeatures;
+    activeComputeUnitCount = src.activeComputeUnitCount;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD& safe_VkPhysicalDeviceShaderCoreProperties2AMD::operator=(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    shaderCoreFeatures = src.shaderCoreFeatures;
+    activeComputeUnitCount = src.activeComputeUnitCount;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceShaderCoreProperties2AMD::~safe_VkPhysicalDeviceShaderCoreProperties2AMD()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct)
+{
+    sType = in_struct->sType;
+    shaderCoreFeatures = in_struct->shaderCoreFeatures;
+    activeComputeUnitCount = in_struct->activeComputeUnitCount;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceShaderCoreProperties2AMD::initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* src)
+{
+    sType = src->sType;
+    shaderCoreFeatures = src->shaderCoreFeatures;
+    activeComputeUnitCount = src->activeComputeUnitCount;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext)
+    deviceCoherentMemory(in_struct->deviceCoherentMemory)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& src)
+{
+    sType = src.sType;
+    deviceCoherentMemory = src.deviceCoherentMemory;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::operator=(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    deviceCoherentMemory = src.deviceCoherentMemory;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct)
+{
+    sType = in_struct->sType;
+    deviceCoherentMemory = in_struct->deviceCoherentMemory;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD::initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* src)
+{
+    sType = src->sType;
+    deviceCoherentMemory = src->deviceCoherentMemory;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct) :
+    sType(in_struct->sType)
 {
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapBudget[i] = in_struct->heapBudget[i];
     }
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapUsage[i] = in_struct->heapUsage[i];
     }
 }
 
-safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT()
+safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapBudget[i] = src.heapBudget[i];
     }
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapUsage[i] = src.heapUsage[i];
     }
 }
@@ -24166,13 +26696,15 @@ safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& safe_VkPhysicalDeviceMemoryBudge
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    pNext = SafePnextCopy(src.pNext);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapBudget[i] = src.heapBudget[i];
     }
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapUsage[i] = src.heapUsage[i];
     }
 
@@ -24181,16 +26713,18 @@ safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT& safe_VkPhysicalDeviceMemoryBudge
 
 safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::~safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const VkPhysicalDeviceMemoryBudgetPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    pNext = SafePnextCopy(in_struct->pNext);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapBudget[i] = in_struct->heapBudget[i];
     }
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapUsage[i] = in_struct->heapUsage[i];
     }
 }
@@ -24198,362 +26732,397 @@ void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const VkPhysical
 void safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT::initialize(const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    pNext = SafePnextCopy(src->pNext);
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapBudget[i] = src->heapBudget[i];
     }
-    for (uint32_t i=0; i<VK_MAX_MEMORY_HEAPS; ++i) {
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_HEAPS; ++i) {
         heapUsage[i] = src->heapUsage[i];
     }
 }
 
 safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     memoryPriority(in_struct->memoryPriority)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT()
+safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     memoryPriority = src.memoryPriority;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::operator=(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     memoryPriority = src.memoryPriority;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::~safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const VkPhysicalDeviceMemoryPriorityFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     memoryPriority = in_struct->memoryPriority;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT::initialize(const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     memoryPriority = src->memoryPriority;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const VkMemoryPriorityAllocateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     priority(in_struct->priority)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT()
+safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkMemoryPriorityAllocateInfoEXT::safe_VkMemoryPriorityAllocateInfoEXT(const safe_VkMemoryPriorityAllocateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     priority = src.priority;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkMemoryPriorityAllocateInfoEXT& safe_VkMemoryPriorityAllocateInfoEXT::operator=(const safe_VkMemoryPriorityAllocateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     priority = src.priority;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkMemoryPriorityAllocateInfoEXT::~safe_VkMemoryPriorityAllocateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const VkMemoryPriorityAllocateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     priority = in_struct->priority;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkMemoryPriorityAllocateInfoEXT::initialize(const safe_VkMemoryPriorityAllocateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     priority = src->priority;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     dedicatedAllocationImageAliasing(in_struct->dedicatedAllocationImageAliasing)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV()
+safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     dedicatedAllocationImageAliasing = src.dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::operator=(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     dedicatedAllocationImageAliasing = src.dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::~safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     dedicatedAllocationImageAliasing = in_struct->dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV::initialize(const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     dedicatedAllocationImageAliasing = src->dedicatedAllocationImageAliasing;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     bufferDeviceAddress(in_struct->bufferDeviceAddress),
     bufferDeviceAddressCaptureReplay(in_struct->bufferDeviceAddressCaptureReplay),
     bufferDeviceAddressMultiDevice(in_struct->bufferDeviceAddressMultiDevice)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT()
+safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     bufferDeviceAddress = src.bufferDeviceAddress;
     bufferDeviceAddressCaptureReplay = src.bufferDeviceAddressCaptureReplay;
     bufferDeviceAddressMultiDevice = src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::operator=(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     bufferDeviceAddress = src.bufferDeviceAddress;
     bufferDeviceAddressCaptureReplay = src.bufferDeviceAddressCaptureReplay;
     bufferDeviceAddressMultiDevice = src.bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::~safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     bufferDeviceAddress = in_struct->bufferDeviceAddress;
     bufferDeviceAddressCaptureReplay = in_struct->bufferDeviceAddressCaptureReplay;
     bufferDeviceAddressMultiDevice = in_struct->bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT::initialize(const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     bufferDeviceAddress = src->bufferDeviceAddress;
     bufferDeviceAddressCaptureReplay = src->bufferDeviceAddressCaptureReplay;
     bufferDeviceAddressMultiDevice = src->bufferDeviceAddressMultiDevice;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBufferDeviceAddressInfoEXT::safe_VkBufferDeviceAddressInfoEXT(const VkBufferDeviceAddressInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     buffer(in_struct->buffer)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBufferDeviceAddressInfoEXT::safe_VkBufferDeviceAddressInfoEXT()
+safe_VkBufferDeviceAddressInfoEXT::safe_VkBufferDeviceAddressInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkBufferDeviceAddressInfoEXT::safe_VkBufferDeviceAddressInfoEXT(const safe_VkBufferDeviceAddressInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBufferDeviceAddressInfoEXT& safe_VkBufferDeviceAddressInfoEXT::operator=(const safe_VkBufferDeviceAddressInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     buffer = src.buffer;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBufferDeviceAddressInfoEXT::~safe_VkBufferDeviceAddressInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBufferDeviceAddressInfoEXT::initialize(const VkBufferDeviceAddressInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     buffer = in_struct->buffer;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBufferDeviceAddressInfoEXT::initialize(const safe_VkBufferDeviceAddressInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     buffer = src->buffer;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT(const VkBufferDeviceAddressCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     deviceAddress(in_struct->deviceAddress)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT()
+safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkBufferDeviceAddressCreateInfoEXT::safe_VkBufferDeviceAddressCreateInfoEXT(const safe_VkBufferDeviceAddressCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     deviceAddress = src.deviceAddress;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkBufferDeviceAddressCreateInfoEXT& safe_VkBufferDeviceAddressCreateInfoEXT::operator=(const safe_VkBufferDeviceAddressCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     deviceAddress = src.deviceAddress;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkBufferDeviceAddressCreateInfoEXT::~safe_VkBufferDeviceAddressCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const VkBufferDeviceAddressCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     deviceAddress = in_struct->deviceAddress;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkBufferDeviceAddressCreateInfoEXT::initialize(const safe_VkBufferDeviceAddressCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     deviceAddress = src->deviceAddress;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkImageStencilUsageCreateInfoEXT::safe_VkImageStencilUsageCreateInfoEXT(const VkImageStencilUsageCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     stencilUsage(in_struct->stencilUsage)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkImageStencilUsageCreateInfoEXT::safe_VkImageStencilUsageCreateInfoEXT()
+safe_VkImageStencilUsageCreateInfoEXT::safe_VkImageStencilUsageCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkImageStencilUsageCreateInfoEXT::safe_VkImageStencilUsageCreateInfoEXT(const safe_VkImageStencilUsageCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     stencilUsage = src.stencilUsage;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkImageStencilUsageCreateInfoEXT& safe_VkImageStencilUsageCreateInfoEXT::operator=(const safe_VkImageStencilUsageCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     stencilUsage = src.stencilUsage;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkImageStencilUsageCreateInfoEXT::~safe_VkImageStencilUsageCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkImageStencilUsageCreateInfoEXT::initialize(const VkImageStencilUsageCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     stencilUsage = in_struct->stencilUsage;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkImageStencilUsageCreateInfoEXT::initialize(const safe_VkImageStencilUsageCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     stencilUsage = src->stencilUsage;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const VkValidationFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     enabledValidationFeatureCount(in_struct->enabledValidationFeatureCount),
     pEnabledValidationFeatures(nullptr),
     disabledValidationFeatureCount(in_struct->disabledValidationFeatureCount),
     pDisabledValidationFeatures(nullptr)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pEnabledValidationFeatures) {
         pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount];
         memcpy ((void *)pEnabledValidationFeatures, (void *)in_struct->pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*in_struct->enabledValidationFeatureCount);
@@ -24565,6 +27134,7 @@ safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const VkValidationFea
 }
 
 safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT() :
+    pNext(nullptr),
     pEnabledValidationFeatures(nullptr),
     pDisabledValidationFeatures(nullptr)
 {}
@@ -24572,11 +27142,11 @@ safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT() :
 safe_VkValidationFeaturesEXT::safe_VkValidationFeaturesEXT(const safe_VkValidationFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     enabledValidationFeatureCount = src.enabledValidationFeatureCount;
     pEnabledValidationFeatures = nullptr;
     disabledValidationFeatureCount = src.disabledValidationFeatureCount;
     pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pEnabledValidationFeatures) {
         pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[src.enabledValidationFeatureCount];
         memcpy ((void *)pEnabledValidationFeatures, (void *)src.pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*src.enabledValidationFeatureCount);
@@ -24595,13 +27165,15 @@ safe_VkValidationFeaturesEXT& safe_VkValidationFeaturesEXT::operator=(const safe
         delete[] pEnabledValidationFeatures;
     if (pDisabledValidationFeatures)
         delete[] pDisabledValidationFeatures;
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     enabledValidationFeatureCount = src.enabledValidationFeatureCount;
     pEnabledValidationFeatures = nullptr;
     disabledValidationFeatureCount = src.disabledValidationFeatureCount;
     pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(src.pNext);
     if (src.pEnabledValidationFeatures) {
         pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[src.enabledValidationFeatureCount];
         memcpy ((void *)pEnabledValidationFeatures, (void *)src.pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*src.enabledValidationFeatureCount);
@@ -24620,16 +27192,18 @@ safe_VkValidationFeaturesEXT::~safe_VkValidationFeaturesEXT()
         delete[] pEnabledValidationFeatures;
     if (pDisabledValidationFeatures)
         delete[] pDisabledValidationFeatures;
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkValidationFeaturesEXT::initialize(const VkValidationFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     enabledValidationFeatureCount = in_struct->enabledValidationFeatureCount;
     pEnabledValidationFeatures = nullptr;
     disabledValidationFeatureCount = in_struct->disabledValidationFeatureCount;
     pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(in_struct->pNext);
     if (in_struct->pEnabledValidationFeatures) {
         pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[in_struct->enabledValidationFeatureCount];
         memcpy ((void *)pEnabledValidationFeatures, (void *)in_struct->pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*in_struct->enabledValidationFeatureCount);
@@ -24643,11 +27217,11 @@ void safe_VkValidationFeaturesEXT::initialize(const VkValidationFeaturesEXT* in_
 void safe_VkValidationFeaturesEXT::initialize(const safe_VkValidationFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     enabledValidationFeatureCount = src->enabledValidationFeatureCount;
     pEnabledValidationFeatures = nullptr;
     disabledValidationFeatureCount = src->disabledValidationFeatureCount;
     pDisabledValidationFeatures = nullptr;
+    pNext = SafePnextCopy(src->pNext);
     if (src->pEnabledValidationFeatures) {
         pEnabledValidationFeatures = new VkValidationFeatureEnableEXT[src->enabledValidationFeatureCount];
         memcpy ((void *)pEnabledValidationFeatures, (void *)src->pEnabledValidationFeatures, sizeof(VkValidationFeatureEnableEXT)*src->enabledValidationFeatureCount);
@@ -24660,7 +27234,6 @@ void safe_VkValidationFeaturesEXT::initialize(const safe_VkValidationFeaturesEXT
 
 safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const VkCooperativeMatrixPropertiesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     MSize(in_struct->MSize),
     NSize(in_struct->NSize),
     KSize(in_struct->KSize),
@@ -24670,15 +27243,16 @@ safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const
     DType(in_struct->DType),
     scope(in_struct->scope)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV()
+safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const safe_VkCooperativeMatrixPropertiesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     MSize = src.MSize;
     NSize = src.NSize;
     KSize = src.KSize;
@@ -24687,15 +27261,17 @@ safe_VkCooperativeMatrixPropertiesNV::safe_VkCooperativeMatrixPropertiesNV(const
     CType = src.CType;
     DType = src.DType;
     scope = src.scope;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkCooperativeMatrixPropertiesNV& safe_VkCooperativeMatrixPropertiesNV::operator=(const safe_VkCooperativeMatrixPropertiesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     MSize = src.MSize;
     NSize = src.NSize;
     KSize = src.KSize;
@@ -24704,18 +27280,20 @@ safe_VkCooperativeMatrixPropertiesNV& safe_VkCooperativeMatrixPropertiesNV::oper
     CType = src.CType;
     DType = src.DType;
     scope = src.scope;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkCooperativeMatrixPropertiesNV::~safe_VkCooperativeMatrixPropertiesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkCooperativeMatrixPropertiesNV::initialize(const VkCooperativeMatrixPropertiesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     MSize = in_struct->MSize;
     NSize = in_struct->NSize;
     KSize = in_struct->KSize;
@@ -24724,12 +27302,12 @@ void safe_VkCooperativeMatrixPropertiesNV::initialize(const VkCooperativeMatrixP
     CType = in_struct->CType;
     DType = in_struct->DType;
     scope = in_struct->scope;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkCooperativeMatrixPropertiesNV::initialize(const safe_VkCooperativeMatrixPropertiesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     MSize = src->MSize;
     NSize = src->NSize;
     KSize = src->KSize;
@@ -24738,419 +27316,460 @@ void safe_VkCooperativeMatrixPropertiesNV::initialize(const safe_VkCooperativeMa
     CType = src->CType;
     DType = src->DType;
     scope = src->scope;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     cooperativeMatrix(in_struct->cooperativeMatrix),
     cooperativeMatrixRobustBufferAccess(in_struct->cooperativeMatrixRobustBufferAccess)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV()
+safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     cooperativeMatrix = src.cooperativeMatrix;
     cooperativeMatrixRobustBufferAccess = src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::operator=(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     cooperativeMatrix = src.cooperativeMatrix;
     cooperativeMatrixRobustBufferAccess = src.cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::~safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const VkPhysicalDeviceCooperativeMatrixFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     cooperativeMatrix = in_struct->cooperativeMatrix;
     cooperativeMatrixRobustBufferAccess = in_struct->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV::initialize(const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     cooperativeMatrix = src->cooperativeMatrix;
     cooperativeMatrixRobustBufferAccess = src->cooperativeMatrixRobustBufferAccess;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     cooperativeMatrixSupportedStages(in_struct->cooperativeMatrixSupportedStages)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV()
+safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     cooperativeMatrixSupportedStages = src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::operator=(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     cooperativeMatrixSupportedStages = src.cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::~safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize(const VkPhysicalDeviceCooperativeMatrixPropertiesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     cooperativeMatrixSupportedStages = in_struct->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV::initialize(const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     cooperativeMatrixSupportedStages = src->cooperativeMatrixSupportedStages;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     coverageReductionMode(in_struct->coverageReductionMode)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV()
+safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     coverageReductionMode = src.coverageReductionMode;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::operator=(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     coverageReductionMode = src.coverageReductionMode;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::~safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize(const VkPhysicalDeviceCoverageReductionModeFeaturesNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     coverageReductionMode = in_struct->coverageReductionMode;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV::initialize(const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     coverageReductionMode = src->coverageReductionMode;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags),
     coverageReductionMode(in_struct->coverageReductionMode)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV()
+safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV() :
+    pNext(nullptr)
 {}
 
 safe_VkPipelineCoverageReductionStateCreateInfoNV::safe_VkPipelineCoverageReductionStateCreateInfoNV(const safe_VkPipelineCoverageReductionStateCreateInfoNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     coverageReductionMode = src.coverageReductionMode;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPipelineCoverageReductionStateCreateInfoNV& safe_VkPipelineCoverageReductionStateCreateInfoNV::operator=(const safe_VkPipelineCoverageReductionStateCreateInfoNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
     coverageReductionMode = src.coverageReductionMode;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPipelineCoverageReductionStateCreateInfoNV::~safe_VkPipelineCoverageReductionStateCreateInfoNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize(const VkPipelineCoverageReductionStateCreateInfoNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
     coverageReductionMode = in_struct->coverageReductionMode;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPipelineCoverageReductionStateCreateInfoNV::initialize(const safe_VkPipelineCoverageReductionStateCreateInfoNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
     coverageReductionMode = src->coverageReductionMode;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV(const VkFramebufferMixedSamplesCombinationNV* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     coverageReductionMode(in_struct->coverageReductionMode),
     rasterizationSamples(in_struct->rasterizationSamples),
     depthStencilSamples(in_struct->depthStencilSamples),
     colorSamples(in_struct->colorSamples)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV()
+safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV() :
+    pNext(nullptr)
 {}
 
 safe_VkFramebufferMixedSamplesCombinationNV::safe_VkFramebufferMixedSamplesCombinationNV(const safe_VkFramebufferMixedSamplesCombinationNV& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     coverageReductionMode = src.coverageReductionMode;
     rasterizationSamples = src.rasterizationSamples;
     depthStencilSamples = src.depthStencilSamples;
     colorSamples = src.colorSamples;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkFramebufferMixedSamplesCombinationNV& safe_VkFramebufferMixedSamplesCombinationNV::operator=(const safe_VkFramebufferMixedSamplesCombinationNV& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     coverageReductionMode = src.coverageReductionMode;
     rasterizationSamples = src.rasterizationSamples;
     depthStencilSamples = src.depthStencilSamples;
     colorSamples = src.colorSamples;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkFramebufferMixedSamplesCombinationNV::~safe_VkFramebufferMixedSamplesCombinationNV()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const VkFramebufferMixedSamplesCombinationNV* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     coverageReductionMode = in_struct->coverageReductionMode;
     rasterizationSamples = in_struct->rasterizationSamples;
     depthStencilSamples = in_struct->depthStencilSamples;
     colorSamples = in_struct->colorSamples;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkFramebufferMixedSamplesCombinationNV::initialize(const safe_VkFramebufferMixedSamplesCombinationNV* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     coverageReductionMode = src->coverageReductionMode;
     rasterizationSamples = src->rasterizationSamples;
     depthStencilSamples = src->depthStencilSamples;
     colorSamples = src->colorSamples;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fragmentShaderSampleInterlock(in_struct->fragmentShaderSampleInterlock),
     fragmentShaderPixelInterlock(in_struct->fragmentShaderPixelInterlock),
     fragmentShaderShadingRateInterlock(in_struct->fragmentShaderShadingRateInterlock)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT()
+safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fragmentShaderSampleInterlock = src.fragmentShaderSampleInterlock;
     fragmentShaderPixelInterlock = src.fragmentShaderPixelInterlock;
     fragmentShaderShadingRateInterlock = src.fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::operator=(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fragmentShaderSampleInterlock = src.fragmentShaderSampleInterlock;
     fragmentShaderPixelInterlock = src.fragmentShaderPixelInterlock;
     fragmentShaderShadingRateInterlock = src.fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::~safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fragmentShaderSampleInterlock = in_struct->fragmentShaderSampleInterlock;
     fragmentShaderPixelInterlock = in_struct->fragmentShaderPixelInterlock;
     fragmentShaderShadingRateInterlock = in_struct->fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::initialize(const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fragmentShaderSampleInterlock = src->fragmentShaderSampleInterlock;
     fragmentShaderPixelInterlock = src->fragmentShaderPixelInterlock;
     fragmentShaderShadingRateInterlock = src->fragmentShaderShadingRateInterlock;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     ycbcrImageArrays(in_struct->ycbcrImageArrays)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT()
+safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     ycbcrImageArrays = src.ycbcrImageArrays;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::operator=(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     ycbcrImageArrays = src.ycbcrImageArrays;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::~safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     ycbcrImageArrays = in_struct->ycbcrImageArrays;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT::initialize(const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     ycbcrImageArrays = src->ycbcrImageArrays;
+    pNext = SafePnextCopy(src->pNext);
 }
 #ifdef VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fullScreenExclusive(in_struct->fullScreenExclusive)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT()
+safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkSurfaceFullScreenExclusiveInfoEXT::safe_VkSurfaceFullScreenExclusiveInfoEXT(const safe_VkSurfaceFullScreenExclusiveInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fullScreenExclusive = src.fullScreenExclusive;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSurfaceFullScreenExclusiveInfoEXT& safe_VkSurfaceFullScreenExclusiveInfoEXT::operator=(const safe_VkSurfaceFullScreenExclusiveInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fullScreenExclusive = src.fullScreenExclusive;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSurfaceFullScreenExclusiveInfoEXT::~safe_VkSurfaceFullScreenExclusiveInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const VkSurfaceFullScreenExclusiveInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fullScreenExclusive = in_struct->fullScreenExclusive;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fullScreenExclusive = src->fullScreenExclusive;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -25159,49 +27778,54 @@ void safe_VkSurfaceFullScreenExclusiveInfoEXT::initialize(const safe_VkSurfaceFu
 
 safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     fullScreenExclusiveSupported(in_struct->fullScreenExclusiveSupported)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT()
+safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     fullScreenExclusiveSupported = src.fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::operator=(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     fullScreenExclusiveSupported = src.fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::~safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const VkSurfaceCapabilitiesFullScreenExclusiveEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     fullScreenExclusiveSupported = in_struct->fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     fullScreenExclusiveSupported = src->fullScreenExclusiveSupported;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
@@ -25210,299 +27834,1851 @@ void safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT::initialize(const safe_VkS
 
 safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     hmonitor(in_struct->hmonitor)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT()
+safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     hmonitor = src.hmonitor;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::operator=(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     hmonitor = src.hmonitor;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::~safe_VkSurfaceFullScreenExclusiveWin32InfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const VkSurfaceFullScreenExclusiveWin32InfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     hmonitor = in_struct->hmonitor;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkSurfaceFullScreenExclusiveWin32InfoEXT::initialize(const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     hmonitor = src->hmonitor;
+    pNext = SafePnextCopy(src->pNext);
 }
 #endif // VK_USE_PLATFORM_WIN32_KHR
 
 
 safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const VkHeadlessSurfaceCreateInfoEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     flags(in_struct->flags)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT()
+safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkHeadlessSurfaceCreateInfoEXT::safe_VkHeadlessSurfaceCreateInfoEXT(const safe_VkHeadlessSurfaceCreateInfoEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkHeadlessSurfaceCreateInfoEXT& safe_VkHeadlessSurfaceCreateInfoEXT::operator=(const safe_VkHeadlessSurfaceCreateInfoEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     flags = src.flags;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkHeadlessSurfaceCreateInfoEXT::~safe_VkHeadlessSurfaceCreateInfoEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const VkHeadlessSurfaceCreateInfoEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     flags = in_struct->flags;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkHeadlessSurfaceCreateInfoEXT::initialize(const safe_VkHeadlessSurfaceCreateInfoEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     flags = src->flags;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct) :
+    sType(in_struct->sType),
+    rectangularLines(in_struct->rectangularLines),
+    bresenhamLines(in_struct->bresenhamLines),
+    smoothLines(in_struct->smoothLines),
+    stippledRectangularLines(in_struct->stippledRectangularLines),
+    stippledBresenhamLines(in_struct->stippledBresenhamLines),
+    stippledSmoothLines(in_struct->stippledSmoothLines)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::safe_VkPhysicalDeviceLineRasterizationFeaturesEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& src)
+{
+    sType = src.sType;
+    rectangularLines = src.rectangularLines;
+    bresenhamLines = src.bresenhamLines;
+    smoothLines = src.smoothLines;
+    stippledRectangularLines = src.stippledRectangularLines;
+    stippledBresenhamLines = src.stippledBresenhamLines;
+    stippledSmoothLines = src.stippledSmoothLines;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    rectangularLines = src.rectangularLines;
+    bresenhamLines = src.bresenhamLines;
+    smoothLines = src.smoothLines;
+    stippledRectangularLines = src.stippledRectangularLines;
+    stippledBresenhamLines = src.stippledBresenhamLines;
+    stippledSmoothLines = src.stippledSmoothLines;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::~safe_VkPhysicalDeviceLineRasterizationFeaturesEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::initialize(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct)
+{
+    sType = in_struct->sType;
+    rectangularLines = in_struct->rectangularLines;
+    bresenhamLines = in_struct->bresenhamLines;
+    smoothLines = in_struct->smoothLines;
+    stippledRectangularLines = in_struct->stippledRectangularLines;
+    stippledBresenhamLines = in_struct->stippledBresenhamLines;
+    stippledSmoothLines = in_struct->stippledSmoothLines;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationFeaturesEXT::initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT* src)
+{
+    sType = src->sType;
+    rectangularLines = src->rectangularLines;
+    bresenhamLines = src->bresenhamLines;
+    smoothLines = src->smoothLines;
+    stippledRectangularLines = src->stippledRectangularLines;
+    stippledBresenhamLines = src->stippledBresenhamLines;
+    stippledSmoothLines = src->stippledSmoothLines;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct) :
+    sType(in_struct->sType),
+    lineSubPixelPrecisionBits(in_struct->lineSubPixelPrecisionBits)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::safe_VkPhysicalDeviceLineRasterizationPropertiesEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& src)
+{
+    sType = src.sType;
+    lineSubPixelPrecisionBits = src.lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::operator=(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    lineSubPixelPrecisionBits = src.lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::~safe_VkPhysicalDeviceLineRasterizationPropertiesEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::initialize(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct)
+{
+    sType = in_struct->sType;
+    lineSubPixelPrecisionBits = in_struct->lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceLineRasterizationPropertiesEXT::initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT* src)
+{
+    sType = src->sType;
+    lineSubPixelPrecisionBits = src->lineSubPixelPrecisionBits;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoEXT::safe_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct) :
+    sType(in_struct->sType),
+    lineRasterizationMode(in_struct->lineRasterizationMode),
+    stippledLineEnable(in_struct->stippledLineEnable),
+    lineStippleFactor(in_struct->lineStippleFactor),
+    lineStipplePattern(in_struct->lineStipplePattern)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoEXT::safe_VkPipelineRasterizationLineStateCreateInfoEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPipelineRasterizationLineStateCreateInfoEXT::safe_VkPipelineRasterizationLineStateCreateInfoEXT(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& src)
+{
+    sType = src.sType;
+    lineRasterizationMode = src.lineRasterizationMode;
+    stippledLineEnable = src.stippledLineEnable;
+    lineStippleFactor = src.lineStippleFactor;
+    lineStipplePattern = src.lineStipplePattern;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoEXT& safe_VkPipelineRasterizationLineStateCreateInfoEXT::operator=(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    lineRasterizationMode = src.lineRasterizationMode;
+    stippledLineEnable = src.stippledLineEnable;
+    lineStippleFactor = src.lineStippleFactor;
+    lineStipplePattern = src.lineStipplePattern;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPipelineRasterizationLineStateCreateInfoEXT::~safe_VkPipelineRasterizationLineStateCreateInfoEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPipelineRasterizationLineStateCreateInfoEXT::initialize(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct)
+{
+    sType = in_struct->sType;
+    lineRasterizationMode = in_struct->lineRasterizationMode;
+    stippledLineEnable = in_struct->stippledLineEnable;
+    lineStippleFactor = in_struct->lineStippleFactor;
+    lineStipplePattern = in_struct->lineStipplePattern;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPipelineRasterizationLineStateCreateInfoEXT::initialize(const safe_VkPipelineRasterizationLineStateCreateInfoEXT* src)
+{
+    sType = src->sType;
+    lineRasterizationMode = src->lineRasterizationMode;
+    stippledLineEnable = src->stippledLineEnable;
+    lineStippleFactor = src->lineStippleFactor;
+    lineStipplePattern = src->lineStipplePattern;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::safe_VkPhysicalDeviceHostQueryResetFeaturesEXT(const VkPhysicalDeviceHostQueryResetFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     hostQueryReset(in_struct->hostQueryReset)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::safe_VkPhysicalDeviceHostQueryResetFeaturesEXT()
+safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::safe_VkPhysicalDeviceHostQueryResetFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::safe_VkPhysicalDeviceHostQueryResetFeaturesEXT(const safe_VkPhysicalDeviceHostQueryResetFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     hostQueryReset = src.hostQueryReset;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceHostQueryResetFeaturesEXT& safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::operator=(const safe_VkPhysicalDeviceHostQueryResetFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     hostQueryReset = src.hostQueryReset;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::~safe_VkPhysicalDeviceHostQueryResetFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::initialize(const VkPhysicalDeviceHostQueryResetFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     hostQueryReset = in_struct->hostQueryReset;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceHostQueryResetFeaturesEXT::initialize(const safe_VkPhysicalDeviceHostQueryResetFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     hostQueryReset = src->hostQueryReset;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct) :
+    sType(in_struct->sType),
+    indexTypeUint8(in_struct->indexTypeUint8)
+{
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT() :
+    pNext(nullptr)
+{}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& src)
+{
+    sType = src.sType;
+    indexTypeUint8 = src.indexTypeUint8;
+    pNext = SafePnextCopy(src.pNext);
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& src)
+{
+    if (&src == this) return *this;
+
+    if (pNext)
+        FreePnextChain(pNext);
+
+    sType = src.sType;
+    indexTypeUint8 = src.indexTypeUint8;
+    pNext = SafePnextCopy(src.pNext);
+
+    return *this;
+}
+
+safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::~safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT()
+{
+    if (pNext)
+        FreePnextChain(pNext);
+}
+
+void safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct)
+{
+    sType = in_struct->sType;
+    indexTypeUint8 = in_struct->indexTypeUint8;
+    pNext = SafePnextCopy(in_struct->pNext);
+}
+
+void safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT::initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT* src)
+{
+    sType = src->sType;
+    indexTypeUint8 = src->indexTypeUint8;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     shaderDemoteToHelperInvocation(in_struct->shaderDemoteToHelperInvocation)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT()
+safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     shaderDemoteToHelperInvocation = src.shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::operator=(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     shaderDemoteToHelperInvocation = src.shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::~safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::initialize(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     shaderDemoteToHelperInvocation = in_struct->shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::initialize(const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     shaderDemoteToHelperInvocation = src->shaderDemoteToHelperInvocation;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     texelBufferAlignment(in_struct->texelBufferAlignment)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT()
+safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     texelBufferAlignment = src.texelBufferAlignment;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     texelBufferAlignment = src.texelBufferAlignment;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::~safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     texelBufferAlignment = in_struct->texelBufferAlignment;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT::initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     texelBufferAlignment = src->texelBufferAlignment;
+    pNext = SafePnextCopy(src->pNext);
 }
 
 safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct) :
     sType(in_struct->sType),
-    pNext(in_struct->pNext),
     storageTexelBufferOffsetAlignmentBytes(in_struct->storageTexelBufferOffsetAlignmentBytes),
     storageTexelBufferOffsetSingleTexelAlignment(in_struct->storageTexelBufferOffsetSingleTexelAlignment),
     uniformTexelBufferOffsetAlignmentBytes(in_struct->uniformTexelBufferOffsetAlignmentBytes),
     uniformTexelBufferOffsetSingleTexelAlignment(in_struct->uniformTexelBufferOffsetSingleTexelAlignment)
 {
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
-safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT()
+safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT() :
+    pNext(nullptr)
 {}
 
 safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& src)
 {
     sType = src.sType;
-    pNext = src.pNext;
     storageTexelBufferOffsetAlignmentBytes = src.storageTexelBufferOffsetAlignmentBytes;
     storageTexelBufferOffsetSingleTexelAlignment = src.storageTexelBufferOffsetSingleTexelAlignment;
     uniformTexelBufferOffsetAlignmentBytes = src.uniformTexelBufferOffsetAlignmentBytes;
     uniformTexelBufferOffsetSingleTexelAlignment = src.uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(src.pNext);
 }
 
 safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::operator=(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT& src)
 {
     if (&src == this) return *this;
 
+    if (pNext)
+        FreePnextChain(pNext);
 
     sType = src.sType;
-    pNext = src.pNext;
     storageTexelBufferOffsetAlignmentBytes = src.storageTexelBufferOffsetAlignmentBytes;
     storageTexelBufferOffsetSingleTexelAlignment = src.storageTexelBufferOffsetSingleTexelAlignment;
     uniformTexelBufferOffsetAlignmentBytes = src.uniformTexelBufferOffsetAlignmentBytes;
     uniformTexelBufferOffsetSingleTexelAlignment = src.uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(src.pNext);
 
     return *this;
 }
 
 safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::~safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT()
 {
+    if (pNext)
+        FreePnextChain(pNext);
 }
 
 void safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::initialize(const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* in_struct)
 {
     sType = in_struct->sType;
-    pNext = in_struct->pNext;
     storageTexelBufferOffsetAlignmentBytes = in_struct->storageTexelBufferOffsetAlignmentBytes;
     storageTexelBufferOffsetSingleTexelAlignment = in_struct->storageTexelBufferOffsetSingleTexelAlignment;
     uniformTexelBufferOffsetAlignmentBytes = in_struct->uniformTexelBufferOffsetAlignmentBytes;
     uniformTexelBufferOffsetSingleTexelAlignment = in_struct->uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(in_struct->pNext);
 }
 
 void safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT::initialize(const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT* src)
 {
     sType = src->sType;
-    pNext = src->pNext;
     storageTexelBufferOffsetAlignmentBytes = src->storageTexelBufferOffsetAlignmentBytes;
     storageTexelBufferOffsetSingleTexelAlignment = src->storageTexelBufferOffsetSingleTexelAlignment;
     uniformTexelBufferOffsetAlignmentBytes = src->uniformTexelBufferOffsetAlignmentBytes;
     uniformTexelBufferOffsetSingleTexelAlignment = src->uniformTexelBufferOffsetSingleTexelAlignment;
+    pNext = SafePnextCopy(src->pNext);
+}
+
+char *SafeStringCopy(const char *in_string) {
+    if (nullptr == in_string) return nullptr;
+    char* dest = new char[std::strlen(in_string) + 1];
+    return std::strcpy(dest, in_string);
+}
+
+void *SafePnextCopy(const void *pNext) {
+    if (!pNext) return nullptr;
+
+    void *safe_pNext;
+    const VkBaseOutStructure *header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
+
+    switch (header->sType) {
+        // Special-case Loader Instance Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: {
+            VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo;
+            // TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses
+            memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo));
+            struct_copy->pNext = SafePnextCopy(header->pNext);
+            safe_pNext = struct_copy;
+            break;
+        }
+        // Special-case Loader Device Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: {
+            VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo;
+            // TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses
+            memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo));
+            struct_copy->pNext = SafePnextCopy(header->pNext);
+            safe_pNext = struct_copy;
+            break;
+        }
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            safe_pNext = new safe_VkPhysicalDeviceSubgroupProperties(reinterpret_cast<const VkPhysicalDeviceSubgroupProperties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            safe_pNext = new safe_VkPhysicalDevice16BitStorageFeatures(reinterpret_cast<const VkPhysicalDevice16BitStorageFeatures *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            safe_pNext = new safe_VkMemoryDedicatedRequirements(reinterpret_cast<const VkMemoryDedicatedRequirements *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+            safe_pNext = new safe_VkMemoryDedicatedAllocateInfo(reinterpret_cast<const VkMemoryDedicatedAllocateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+            safe_pNext = new safe_VkMemoryAllocateFlagsInfo(reinterpret_cast<const VkMemoryAllocateFlagsInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+            safe_pNext = new safe_VkDeviceGroupRenderPassBeginInfo(reinterpret_cast<const VkDeviceGroupRenderPassBeginInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+            safe_pNext = new safe_VkDeviceGroupCommandBufferBeginInfo(reinterpret_cast<const VkDeviceGroupCommandBufferBeginInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+            safe_pNext = new safe_VkDeviceGroupSubmitInfo(reinterpret_cast<const VkDeviceGroupSubmitInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+            safe_pNext = new safe_VkDeviceGroupBindSparseInfo(reinterpret_cast<const VkDeviceGroupBindSparseInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+            safe_pNext = new safe_VkBindBufferMemoryDeviceGroupInfo(reinterpret_cast<const VkBindBufferMemoryDeviceGroupInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+            safe_pNext = new safe_VkBindImageMemoryDeviceGroupInfo(reinterpret_cast<const VkBindImageMemoryDeviceGroupInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+            safe_pNext = new safe_VkDeviceGroupDeviceCreateInfo(reinterpret_cast<const VkDeviceGroupDeviceCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+            safe_pNext = new safe_VkPhysicalDeviceFeatures2(reinterpret_cast<const VkPhysicalDeviceFeatures2 *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            safe_pNext = new safe_VkPhysicalDevicePointClippingProperties(reinterpret_cast<const VkPhysicalDevicePointClippingProperties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+            safe_pNext = new safe_VkRenderPassInputAttachmentAspectCreateInfo(reinterpret_cast<const VkRenderPassInputAttachmentAspectCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            safe_pNext = new safe_VkImageViewUsageCreateInfo(reinterpret_cast<const VkImageViewUsageCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+            safe_pNext = new safe_VkPipelineTessellationDomainOriginStateCreateInfo(reinterpret_cast<const VkPipelineTessellationDomainOriginStateCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+            safe_pNext = new safe_VkRenderPassMultiviewCreateInfo(reinterpret_cast<const VkRenderPassMultiviewCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            safe_pNext = new safe_VkPhysicalDeviceMultiviewFeatures(reinterpret_cast<const VkPhysicalDeviceMultiviewFeatures *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            safe_pNext = new safe_VkPhysicalDeviceMultiviewProperties(reinterpret_cast<const VkPhysicalDeviceMultiviewProperties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            safe_pNext = new safe_VkPhysicalDeviceVariablePointersFeatures(reinterpret_cast<const VkPhysicalDeviceVariablePointersFeatures *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryFeatures(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryFeatures *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            safe_pNext = new safe_VkPhysicalDeviceProtectedMemoryProperties(reinterpret_cast<const VkPhysicalDeviceProtectedMemoryProperties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+            safe_pNext = new safe_VkProtectedSubmitInfo(reinterpret_cast<const VkProtectedSubmitInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            safe_pNext = new safe_VkSamplerYcbcrConversionInfo(reinterpret_cast<const VkSamplerYcbcrConversionInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+            safe_pNext = new safe_VkBindImagePlaneMemoryInfo(reinterpret_cast<const VkBindImagePlaneMemoryInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+            safe_pNext = new safe_VkImagePlaneMemoryRequirementsInfo(reinterpret_cast<const VkImagePlaneMemoryRequirementsInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            safe_pNext = new safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures(reinterpret_cast<const VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            safe_pNext = new safe_VkSamplerYcbcrConversionImageFormatProperties(reinterpret_cast<const VkSamplerYcbcrConversionImageFormatProperties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+            safe_pNext = new safe_VkPhysicalDeviceExternalImageFormatInfo(reinterpret_cast<const VkPhysicalDeviceExternalImageFormatInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            safe_pNext = new safe_VkExternalImageFormatProperties(reinterpret_cast<const VkExternalImageFormatProperties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            safe_pNext = new safe_VkPhysicalDeviceIDProperties(reinterpret_cast<const VkPhysicalDeviceIDProperties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            safe_pNext = new safe_VkExternalMemoryImageCreateInfo(reinterpret_cast<const VkExternalMemoryImageCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            safe_pNext = new safe_VkExternalMemoryBufferCreateInfo(reinterpret_cast<const VkExternalMemoryBufferCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+            safe_pNext = new safe_VkExportMemoryAllocateInfo(reinterpret_cast<const VkExportMemoryAllocateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            safe_pNext = new safe_VkExportFenceCreateInfo(reinterpret_cast<const VkExportFenceCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            safe_pNext = new safe_VkExportSemaphoreCreateInfo(reinterpret_cast<const VkExportSemaphoreCreateInfo *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            safe_pNext = new safe_VkPhysicalDeviceMaintenance3Properties(reinterpret_cast<const VkPhysicalDeviceMaintenance3Properties *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            safe_pNext = new safe_VkPhysicalDeviceShaderDrawParametersFeatures(reinterpret_cast<const VkPhysicalDeviceShaderDrawParametersFeatures *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+            safe_pNext = new safe_VkImageSwapchainCreateInfoKHR(reinterpret_cast<const VkImageSwapchainCreateInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+            safe_pNext = new safe_VkBindImageMemorySwapchainInfoKHR(reinterpret_cast<const VkBindImageMemorySwapchainInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+            safe_pNext = new safe_VkDeviceGroupPresentInfoKHR(reinterpret_cast<const VkDeviceGroupPresentInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+            safe_pNext = new safe_VkDeviceGroupSwapchainCreateInfoKHR(reinterpret_cast<const VkDeviceGroupSwapchainCreateInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+            safe_pNext = new safe_VkDisplayPresentInfoKHR(reinterpret_cast<const VkDisplayPresentInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+            safe_pNext = new safe_VkImportMemoryFdInfoKHR(reinterpret_cast<const VkImportMemoryFdInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+            safe_pNext = new safe_VkPhysicalDevicePushDescriptorPropertiesKHR(reinterpret_cast<const VkPhysicalDevicePushDescriptorPropertiesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+            safe_pNext = new safe_VkPresentRegionsKHR(reinterpret_cast<const VkPresentRegionsKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceImagelessFramebufferFeaturesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR:
+            safe_pNext = new safe_VkFramebufferAttachmentsCreateInfoKHR(reinterpret_cast<const VkFramebufferAttachmentsCreateInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR:
+            safe_pNext = new safe_VkRenderPassAttachmentBeginInfoKHR(reinterpret_cast<const VkRenderPassAttachmentBeginInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+            safe_pNext = new safe_VkSharedPresentSurfaceCapabilitiesKHR(reinterpret_cast<const VkSharedPresentSurfaceCapabilitiesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+            safe_pNext = new safe_VkImageFormatListCreateInfoKHR(reinterpret_cast<const VkImageFormatListCreateInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+            safe_pNext = new safe_VkPhysicalDevice8BitStorageFeaturesKHR(reinterpret_cast<const VkPhysicalDevice8BitStorageFeaturesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR(reinterpret_cast<const VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceDriverPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceDriverPropertiesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceFloatControlsPropertiesKHR(reinterpret_cast<const VkPhysicalDeviceFloatControlsPropertiesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR:
+            safe_pNext = new safe_VkSubpassDescriptionDepthStencilResolveKHR(reinterpret_cast<const VkSubpassDescriptionDepthStencilResolveKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR(reinterpret_cast<const VkPhysicalDeviceDepthStencilResolvePropertiesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
+            safe_pNext = new safe_VkSurfaceProtectedCapabilitiesKHR(reinterpret_cast<const VkSurfaceProtectedCapabilitiesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR:
+            safe_pNext = new safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR(reinterpret_cast<const VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+            safe_pNext = new safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(reinterpret_cast<const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkDebugReportCallbackCreateInfoEXT(reinterpret_cast<const VkDebugReportCallbackCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+            safe_pNext = new safe_VkPipelineRasterizationStateRasterizationOrderAMD(reinterpret_cast<const VkPipelineRasterizationStateRasterizationOrderAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkDedicatedAllocationImageCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationImageCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+            safe_pNext = new safe_VkDedicatedAllocationBufferCreateInfoNV(reinterpret_cast<const VkDedicatedAllocationBufferCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+            safe_pNext = new safe_VkDedicatedAllocationMemoryAllocateInfoNV(reinterpret_cast<const VkDedicatedAllocationMemoryAllocateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineRasterizationStateStreamCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationStateStreamCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+            safe_pNext = new safe_VkTextureLODGatherFormatPropertiesAMD(reinterpret_cast<const VkTextureLODGatherFormatPropertiesAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceCornerSampledImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCornerSampledImageFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkExternalMemoryImageCreateInfoNV(reinterpret_cast<const VkExternalMemoryImageCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+            safe_pNext = new safe_VkExportMemoryAllocateInfoNV(reinterpret_cast<const VkExportMemoryAllocateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+            safe_pNext = new safe_VkValidationFlagsEXT(reinterpret_cast<const VkValidationFlagsEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+            safe_pNext = new safe_VkImageViewASTCDecodeModeEXT(reinterpret_cast<const VkImageViewASTCDecodeModeEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceASTCDecodeFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceASTCDecodeFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+            safe_pNext = new safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT(reinterpret_cast<const VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineViewportWScalingStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportWScalingStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkSwapchainCounterCreateInfoEXT(reinterpret_cast<const VkSwapchainCounterCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+            safe_pNext = new safe_VkPresentTimesInfoGOOGLE(reinterpret_cast<const VkPresentTimesInfoGOOGLE *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+            safe_pNext = new safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX(reinterpret_cast<const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineViewportSwizzleStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportSwizzleStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineDiscardRectangleStateCreateInfoEXT(reinterpret_cast<const VkPipelineDiscardRectangleStateCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineRasterizationConservativeStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationConservativeStateCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkDebugUtilsMessengerCreateInfoEXT(reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkSamplerReductionModeCreateInfoEXT(reinterpret_cast<const VkSamplerReductionModeCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
+            safe_pNext = new safe_VkWriteDescriptorSetInlineUniformBlockEXT(reinterpret_cast<const VkWriteDescriptorSetInlineUniformBlockEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT(reinterpret_cast<const VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+            safe_pNext = new safe_VkSampleLocationsInfoEXT(reinterpret_cast<const VkSampleLocationsInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+            safe_pNext = new safe_VkRenderPassSampleLocationsBeginInfoEXT(reinterpret_cast<const VkRenderPassSampleLocationsBeginInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineSampleLocationsStateCreateInfoEXT(reinterpret_cast<const VkPipelineSampleLocationsStateCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceSampleLocationsPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceSampleLocationsPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT(reinterpret_cast<const VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineCoverageToColorStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageToColorStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineCoverageModulationStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageModulationStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            safe_pNext = new safe_VkDrmFormatModifierPropertiesListEXT(reinterpret_cast<const VkDrmFormatModifierPropertiesListEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkImageDrmFormatModifierListCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierListCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkImageDrmFormatModifierExplicitCreateInfoEXT(reinterpret_cast<const VkImageDrmFormatModifierExplicitCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkShaderModuleValidationCacheCreateInfoEXT(reinterpret_cast<const VkShaderModuleValidationCacheCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT(reinterpret_cast<const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceDescriptorIndexingPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+            safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountAllocateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+            safe_pNext = new safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT(reinterpret_cast<const VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineViewportShadingRateImageStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportShadingRateImageStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceShadingRateImageFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShadingRateImageFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceShadingRateImagePropertiesNV(reinterpret_cast<const VkPhysicalDeviceShadingRateImagePropertiesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
+            safe_pNext = new safe_VkWriteDescriptorSetAccelerationStructureNV(reinterpret_cast<const VkWriteDescriptorSetAccelerationStructureNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceRayTracingPropertiesNV(reinterpret_cast<const VkPhysicalDeviceRayTracingPropertiesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV(reinterpret_cast<const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV(reinterpret_cast<const VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceImageViewImageFormatInfoEXT(reinterpret_cast<const VkPhysicalDeviceImageViewImageFormatInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
+            safe_pNext = new safe_VkFilterCubicImageViewImageFormatPropertiesEXT(reinterpret_cast<const VkFilterCubicImageViewImageFormatPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkDeviceQueueGlobalPriorityCreateInfoEXT(reinterpret_cast<const VkDeviceQueueGlobalPriorityCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+            safe_pNext = new safe_VkImportMemoryHostPointerInfoEXT(reinterpret_cast<const VkImportMemoryHostPointerInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+            safe_pNext = new safe_VkPipelineCompilerControlCreateInfoAMD(reinterpret_cast<const VkPipelineCompilerControlCreateInfoAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+            safe_pNext = new safe_VkPhysicalDeviceShaderCorePropertiesAMD(reinterpret_cast<const VkPhysicalDeviceShaderCorePropertiesAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+            safe_pNext = new safe_VkDeviceMemoryOverallocationCreateInfoAMD(reinterpret_cast<const VkDeviceMemoryOverallocationCreateInfoAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineVertexInputDivisorStateCreateInfoEXT(reinterpret_cast<const VkPipelineVertexInputDivisorStateCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineCreationFeedbackCreateInfoEXT(reinterpret_cast<const VkPipelineCreationFeedbackCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV(reinterpret_cast<const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceMeshShaderFeaturesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceMeshShaderPropertiesNV(reinterpret_cast<const VkPhysicalDeviceMeshShaderPropertiesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV(reinterpret_cast<const VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV(reinterpret_cast<const VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV(reinterpret_cast<const VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceExclusiveScissorFeaturesNV(reinterpret_cast<const VkPhysicalDeviceExclusiveScissorFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+            safe_pNext = new safe_VkQueueFamilyCheckpointPropertiesNV(reinterpret_cast<const VkQueueFamilyCheckpointPropertiesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+            safe_pNext = new safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(reinterpret_cast<const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDevicePCIBusInfoPropertiesEXT(reinterpret_cast<const VkPhysicalDevicePCIBusInfoPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
+            safe_pNext = new safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD(reinterpret_cast<const VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
+            safe_pNext = new safe_VkSwapchainDisplayNativeHdrCreateInfoAMD(reinterpret_cast<const VkSwapchainDisplayNativeHdrCreateInfoAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkRenderPassFragmentDensityMapCreateInfoEXT(reinterpret_cast<const VkRenderPassFragmentDensityMapCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(reinterpret_cast<const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+            safe_pNext = new safe_VkPhysicalDeviceShaderCoreProperties2AMD(reinterpret_cast<const VkPhysicalDeviceShaderCoreProperties2AMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+            safe_pNext = new safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(reinterpret_cast<const VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+            safe_pNext = new safe_VkMemoryPriorityAllocateInfoEXT(reinterpret_cast<const VkMemoryPriorityAllocateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV(reinterpret_cast<const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkBufferDeviceAddressCreateInfoEXT(reinterpret_cast<const VkBufferDeviceAddressCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkImageStencilUsageCreateInfoEXT(reinterpret_cast<const VkImageStencilUsageCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+            safe_pNext = new safe_VkValidationFeaturesEXT(reinterpret_cast<const VkValidationFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV(reinterpret_cast<const VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+            safe_pNext = new safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV(reinterpret_cast<const VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+            safe_pNext = new safe_VkPipelineCoverageReductionStateCreateInfoNV(reinterpret_cast<const VkPipelineCoverageReductionStateCreateInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceLineRasterizationFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceLineRasterizationPropertiesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
+            safe_pNext = new safe_VkPipelineRasterizationLineStateCreateInfoEXT(reinterpret_cast<const VkPipelineRasterizationLineStateCreateInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceHostQueryResetFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceHostQueryResetFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(reinterpret_cast<const VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
+            safe_pNext = new safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT(reinterpret_cast<const VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(pNext));
+            break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+            safe_pNext = new safe_VkAndroidHardwareBufferUsageANDROID(reinterpret_cast<const VkAndroidHardwareBufferUsageANDROID *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+            safe_pNext = new safe_VkAndroidHardwareBufferFormatPropertiesANDROID(reinterpret_cast<const VkAndroidHardwareBufferFormatPropertiesANDROID *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+            safe_pNext = new safe_VkImportAndroidHardwareBufferInfoANDROID(reinterpret_cast<const VkImportAndroidHardwareBufferInfoANDROID *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+            safe_pNext = new safe_VkExternalFormatANDROID(reinterpret_cast<const VkExternalFormatANDROID *>(pNext));
+            break;
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
+            safe_pNext = new safe_VkPresentFrameTokenGGP(reinterpret_cast<const VkPresentFrameTokenGGP *>(pNext));
+            break;
+#endif // VK_USE_PLATFORM_GGP
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            safe_pNext = new safe_VkImportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkImportMemoryWin32HandleInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            safe_pNext = new safe_VkExportMemoryWin32HandleInfoKHR(reinterpret_cast<const VkExportMemoryWin32HandleInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+            safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoKHR(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+            safe_pNext = new safe_VkExportSemaphoreWin32HandleInfoKHR(reinterpret_cast<const VkExportSemaphoreWin32HandleInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+            safe_pNext = new safe_VkD3D12FenceSubmitInfoKHR(reinterpret_cast<const VkD3D12FenceSubmitInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+            safe_pNext = new safe_VkExportFenceWin32HandleInfoKHR(reinterpret_cast<const VkExportFenceWin32HandleInfoKHR *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            safe_pNext = new safe_VkImportMemoryWin32HandleInfoNV(reinterpret_cast<const VkImportMemoryWin32HandleInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            safe_pNext = new safe_VkExportMemoryWin32HandleInfoNV(reinterpret_cast<const VkExportMemoryWin32HandleInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+            safe_pNext = new safe_VkWin32KeyedMutexAcquireReleaseInfoNV(reinterpret_cast<const VkWin32KeyedMutexAcquireReleaseInfoNV *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
+            safe_pNext = new safe_VkSurfaceFullScreenExclusiveInfoEXT(reinterpret_cast<const VkSurfaceFullScreenExclusiveInfoEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
+            safe_pNext = new safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT(reinterpret_cast<const VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(pNext));
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
+            safe_pNext = new safe_VkSurfaceFullScreenExclusiveWin32InfoEXT(reinterpret_cast<const VkSurfaceFullScreenExclusiveWin32InfoEXT *>(pNext));
+            break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+        default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain
+            safe_pNext = SafePnextCopy(header->pNext);
+            break;
+    }
+
+    return safe_pNext;
+}
+
+void FreePnextChain(const void *pNext) {
+    if (!pNext) return;
+
+    auto header = reinterpret_cast<const VkBaseOutStructure *>(pNext);
+
+    switch (header->sType) {
+        // Special-case Loader Instance Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:
+            FreePnextChain(header->pNext);
+            delete reinterpret_cast<const VkLayerInstanceCreateInfo *>(pNext);
+            break;
+        // Special-case Loader Device Struct passed to/from layer in pNext chain
+        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:
+            FreePnextChain(header->pNext);
+            delete reinterpret_cast<const VkLayerDeviceCreateInfo *>(pNext);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDevice16BitStorageFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS:
+            delete reinterpret_cast<const safe_VkMemoryDedicatedRequirements *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO:
+            delete reinterpret_cast<const safe_VkMemoryDedicatedAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO:
+            delete reinterpret_cast<const safe_VkMemoryAllocateFlagsInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupRenderPassBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupCommandBufferBeginInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupBindSparseInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO:
+            delete reinterpret_cast<const safe_VkBindBufferMemoryDeviceGroupInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO:
+            delete reinterpret_cast<const safe_VkBindImageMemoryDeviceGroupInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkDeviceGroupDeviceCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFeatures2 *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePointClippingProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkRenderPassInputAttachmentAspectCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkImageViewUsageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkPipelineTessellationDomainOriginStateCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkRenderPassMultiviewCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVariablePointersFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceProtectedMemoryProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO:
+            delete reinterpret_cast<const safe_VkProtectedSubmitInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO:
+            delete reinterpret_cast<const safe_VkBindImagePlaneMemoryInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO:
+            delete reinterpret_cast<const safe_VkImagePlaneMemoryRequirementsInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES:
+            delete reinterpret_cast<const safe_VkSamplerYcbcrConversionImageFormatProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalImageFormatInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
+            delete reinterpret_cast<const safe_VkExternalImageFormatProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceIDProperties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExternalMemoryBufferCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO:
+            delete reinterpret_cast<const safe_VkExportMemoryAllocateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExportFenceCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            delete reinterpret_cast<const safe_VkExportSemaphoreCreateInfo *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMaintenance3Properties *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDrawParametersFeatures *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkImageSwapchainCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR:
+            delete reinterpret_cast<const safe_VkBindImageMemorySwapchainInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkDeviceGroupPresentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkDeviceGroupSwapchainCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkDisplayPresentInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:
+            delete reinterpret_cast<const safe_VkImportMemoryFdInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePushDescriptorPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:
+            delete reinterpret_cast<const safe_VkPresentRegionsKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImagelessFramebufferFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkFramebufferAttachmentsCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR:
+            delete reinterpret_cast<const safe_VkRenderPassAttachmentBeginInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkSharedPresentSurfaceCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkImageFormatListCreateInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevice8BitStorageFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDriverPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFloatControlsPropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR:
+            delete reinterpret_cast<const safe_VkSubpassDescriptionDepthStencilResolveKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthStencilResolvePropertiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVulkanMemoryModelFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR:
+            delete reinterpret_cast<const safe_VkSurfaceProtectedCapabilitiesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDebugReportCallbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationStateRasterizationOrderAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkDedicatedAllocationImageCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkDedicatedAllocationBufferCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkDedicatedAllocationMemoryAllocateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTransformFeedbackPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationStateStreamCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD:
+            delete reinterpret_cast<const safe_VkTextureLODGatherFormatPropertiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCornerSampledImageFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkExternalMemoryImageCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkExportMemoryAllocateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:
+            delete reinterpret_cast<const safe_VkValidationFlagsEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT:
+            delete reinterpret_cast<const safe_VkImageViewASTCDecodeModeEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceASTCDecodeFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceConditionalRenderingFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT:
+            delete reinterpret_cast<const safe_VkCommandBufferInheritanceConditionalRenderingInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportWScalingStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSwapchainCounterCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:
+            delete reinterpret_cast<const safe_VkPresentTimesInfoGOOGLE *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportSwizzleStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDiscardRectanglePropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineDiscardRectangleStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceConservativeRasterizationPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationConservativeStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationDepthClipStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDebugUtilsMessengerCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSamplerReductionModeCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceInlineUniformBlockPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT:
+            delete reinterpret_cast<const safe_VkWriteDescriptorSetInlineUniformBlockEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDescriptorPoolInlineUniformBlockCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSampleLocationsInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT:
+            delete reinterpret_cast<const safe_VkRenderPassSampleLocationsBeginInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineSampleLocationsStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSampleLocationsPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineColorBlendAdvancedStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineCoverageToColorStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineCoverageModulationStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderSMBuiltinsFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT:
+            delete reinterpret_cast<const safe_VkDrmFormatModifierPropertiesListEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageDrmFormatModifierInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImageDrmFormatModifierListCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImageDrmFormatModifierExplicitCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkShaderModuleValidationCacheCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDescriptorIndexingPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountAllocateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT:
+            delete reinterpret_cast<const safe_VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportShadingRateImageStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImageFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShadingRateImagePropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportCoarseSampleOrderStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV:
+            delete reinterpret_cast<const safe_VkWriteDescriptorSetAccelerationStructureNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRayTracingPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineRepresentativeFragmentTestStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceImageViewImageFormatInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkFilterCubicImageViewImageFormatPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkDeviceQueueGlobalPriorityCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImportMemoryHostPointerInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD:
+            delete reinterpret_cast<const safe_VkPipelineCompilerControlCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCorePropertiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD:
+            delete reinterpret_cast<const safe_VkDeviceMemoryOverallocationCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineVertexInputDivisorStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineCreationFeedbackCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceComputeShaderDerivativesFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMeshShaderPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderImageFootprintFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineViewportExclusiveScissorStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceExclusiveScissorFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkQueueFamilyCheckpointPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDevicePCIBusInfoPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD:
+            delete reinterpret_cast<const safe_VkDisplayNativeHdrSurfaceCapabilitiesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD:
+            delete reinterpret_cast<const safe_VkSwapchainDisplayNativeHdrCreateInfoAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentDensityMapPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkRenderPassFragmentDensityMapCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderCoreProperties2AMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceMemoryPriorityFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkMemoryPriorityAllocateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceBufferDeviceAddressFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkBufferDeviceAddressCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkImageStencilUsageCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkValidationFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCooperativeMatrixPropertiesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceCoverageReductionModeFeaturesNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV:
+            delete reinterpret_cast<const safe_VkPipelineCoverageReductionStateCreateInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceYcbcrImageArraysFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkPipelineRasterizationLineStateCreateInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceHostQueryResetFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT:
+            delete reinterpret_cast<const safe_VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT *>(header);
+            break;
+#ifdef VK_USE_PLATFORM_ANDROID_KHR
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID:
+            delete reinterpret_cast<const safe_VkAndroidHardwareBufferUsageANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID:
+            delete reinterpret_cast<const safe_VkAndroidHardwareBufferFormatPropertiesANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID:
+            delete reinterpret_cast<const safe_VkImportAndroidHardwareBufferInfoANDROID *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID:
+            delete reinterpret_cast<const safe_VkExternalFormatANDROID *>(header);
+            break;
+#endif // VK_USE_PLATFORM_ANDROID_KHR
+#ifdef VK_USE_PLATFORM_GGP
+        case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP:
+            delete reinterpret_cast<const safe_VkPresentFrameTokenGGP *>(header);
+            break;
+#endif // VK_USE_PLATFORM_GGP
+#ifdef VK_USE_PLATFORM_WIN32_KHR
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkExportSemaphoreWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:
+            delete reinterpret_cast<const safe_VkD3D12FenceSubmitInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:
+            delete reinterpret_cast<const safe_VkExportFenceWin32HandleInfoKHR *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            delete reinterpret_cast<const safe_VkImportMemoryWin32HandleInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:
+            delete reinterpret_cast<const safe_VkExportMemoryWin32HandleInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:
+            delete reinterpret_cast<const safe_VkWin32KeyedMutexAcquireReleaseInfoNV *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveInfoEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT:
+            delete reinterpret_cast<const safe_VkSurfaceCapabilitiesFullScreenExclusiveEXT *>(header);
+            break;
+        case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT:
+            delete reinterpret_cast<const safe_VkSurfaceFullScreenExclusiveWin32InfoEXT *>(header);
+            break;
+#endif // VK_USE_PLATFORM_WIN32_KHR
+        default: // Encountered an unknown sType -- panic, there should be none such in safe chain
+            assert(false);
+            FreePnextChain(header->pNext);
+            break;
+    }
 }
diff --git a/layers/generated/vk_safe_struct.h b/layers/generated/vk_safe_struct.h
index b04e4570e..ca7c83e88 100644
--- a/layers/generated/vk_safe_struct.h
+++ b/layers/generated/vk_safe_struct.h
@@ -33,6 +33,10 @@
 #pragma once
 #include <vulkan/vulkan.h>
 
+void *SafePnextCopy(const void *pNext);
+void FreePnextChain(const void *pNext);
+char *SafeStringCopy(const char *in_string);
+
 
 struct safe_VkApplicationInfo {
     VkStructureType sType;
@@ -1072,34 +1076,6 @@ struct safe_VkRenderPassBeginInfo {
     VkRenderPassBeginInfo const *ptr() const { return reinterpret_cast<VkRenderPassBeginInfo const *>(this); }
 };
 
-struct safe_VkBaseOutStructure {
-    VkStructureType sType;
-    safe_VkBaseOutStructure* pNext;
-    safe_VkBaseOutStructure(const VkBaseOutStructure* in_struct);
-    safe_VkBaseOutStructure(const safe_VkBaseOutStructure& src);
-    safe_VkBaseOutStructure& operator=(const safe_VkBaseOutStructure& src);
-    safe_VkBaseOutStructure();
-    ~safe_VkBaseOutStructure();
-    void initialize(const VkBaseOutStructure* in_struct);
-    void initialize(const safe_VkBaseOutStructure* src);
-    VkBaseOutStructure *ptr() { return reinterpret_cast<VkBaseOutStructure *>(this); }
-    VkBaseOutStructure const *ptr() const { return reinterpret_cast<VkBaseOutStructure const *>(this); }
-};
-
-struct safe_VkBaseInStructure {
-    VkStructureType sType;
-    safe_VkBaseInStructure* pNext;
-    safe_VkBaseInStructure(const VkBaseInStructure* in_struct);
-    safe_VkBaseInStructure(const safe_VkBaseInStructure& src);
-    safe_VkBaseInStructure& operator=(const safe_VkBaseInStructure& src);
-    safe_VkBaseInStructure();
-    ~safe_VkBaseInStructure();
-    void initialize(const VkBaseInStructure* in_struct);
-    void initialize(const safe_VkBaseInStructure* src);
-    VkBaseInStructure *ptr() { return reinterpret_cast<VkBaseInStructure *>(this); }
-    VkBaseInStructure const *ptr() const { return reinterpret_cast<VkBaseInStructure const *>(this); }
-};
-
 struct safe_VkPhysicalDeviceSubgroupProperties {
     VkStructureType sType;
     void* pNext;
@@ -2734,20 +2710,20 @@ struct safe_VkPhysicalDevicePushDescriptorPropertiesKHR {
     VkPhysicalDevicePushDescriptorPropertiesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePushDescriptorPropertiesKHR const *>(this); }
 };
 
-struct safe_VkPhysicalDeviceFloat16Int8FeaturesKHR {
+struct safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR {
     VkStructureType sType;
     void* pNext;
     VkBool32 shaderFloat16;
     VkBool32 shaderInt8;
-    safe_VkPhysicalDeviceFloat16Int8FeaturesKHR(const VkPhysicalDeviceFloat16Int8FeaturesKHR* in_struct);
-    safe_VkPhysicalDeviceFloat16Int8FeaturesKHR(const safe_VkPhysicalDeviceFloat16Int8FeaturesKHR& src);
-    safe_VkPhysicalDeviceFloat16Int8FeaturesKHR& operator=(const safe_VkPhysicalDeviceFloat16Int8FeaturesKHR& src);
-    safe_VkPhysicalDeviceFloat16Int8FeaturesKHR();
-    ~safe_VkPhysicalDeviceFloat16Int8FeaturesKHR();
-    void initialize(const VkPhysicalDeviceFloat16Int8FeaturesKHR* in_struct);
-    void initialize(const safe_VkPhysicalDeviceFloat16Int8FeaturesKHR* src);
-    VkPhysicalDeviceFloat16Int8FeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceFloat16Int8FeaturesKHR *>(this); }
-    VkPhysicalDeviceFloat16Int8FeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceFloat16Int8FeaturesKHR const *>(this); }
+    safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct);
+    safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src);
+    safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& operator=(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR& src);
+    safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR();
+    ~safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR();
+    void initialize(const VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* in_struct);
+    void initialize(const safe_VkPhysicalDeviceShaderFloat16Int8FeaturesKHR* src);
+    VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR *>(this); }
+    VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR const *>(this); }
 };
 
 struct safe_VkPresentRegionKHR {
@@ -3285,8 +3261,8 @@ struct safe_VkPhysicalDeviceDriverPropertiesKHR {
 struct safe_VkPhysicalDeviceFloatControlsPropertiesKHR {
     VkStructureType sType;
     void* pNext;
-    VkBool32 separateDenormSettings;
-    VkBool32 separateRoundingModeSettings;
+    VkShaderFloatControlsIndependenceKHR denormBehaviorIndependence;
+    VkShaderFloatControlsIndependenceKHR roundingModeIndependence;
     VkBool32 shaderSignedZeroInfNanPreserveFloat16;
     VkBool32 shaderSignedZeroInfNanPreserveFloat32;
     VkBool32 shaderSignedZeroInfNanPreserveFloat64;
@@ -3395,6 +3371,107 @@ struct safe_VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR {
     VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR const *>(this); }
 };
 
+struct safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+    VkStructureType sType;
+    void* pNext;
+    VkBool32 pipelineExecutableInfo;
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct);
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src);
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& operator=(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& src);
+    safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
+    ~safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR();
+    void initialize(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* in_struct);
+    void initialize(const safe_VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR* src);
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *ptr() { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *>(this); }
+    VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *ptr() const { return reinterpret_cast<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR const *>(this); }
+};
+
+struct safe_VkPipelineInfoKHR {
+    VkStructureType sType;
+    const void* pNext;
+    VkPipeline pipeline;
+    safe_VkPipelineInfoKHR(const VkPipelineInfoKHR* in_struct);
+    safe_VkPipelineInfoKHR(const safe_VkPipelineInfoKHR& src);
+    safe_VkPipelineInfoKHR& operator=(const safe_VkPipelineInfoKHR& src);
+    safe_VkPipelineInfoKHR();
+    ~safe_VkPipelineInfoKHR();
+    void initialize(const VkPipelineInfoKHR* in_struct);
+    void initialize(const safe_VkPipelineInfoKHR* src);
+    VkPipelineInfoKHR *ptr() { return reinterpret_cast<VkPipelineInfoKHR *>(this); }
+    VkPipelineInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineInfoKHR const *>(this); }
+};
+
+struct safe_VkPipelineExecutablePropertiesKHR {
+    VkStructureType sType;
+    void* pNext;
+    VkShaderStageFlags stages;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    uint32_t subgroupSize;
+    safe_VkPipelineExecutablePropertiesKHR(const VkPipelineExecutablePropertiesKHR* in_struct);
+    safe_VkPipelineExecutablePropertiesKHR(const safe_VkPipelineExecutablePropertiesKHR& src);
+    safe_VkPipelineExecutablePropertiesKHR& operator=(const safe_VkPipelineExecutablePropertiesKHR& src);
+    safe_VkPipelineExecutablePropertiesKHR();
+    ~safe_VkPipelineExecutablePropertiesKHR();
+    void initialize(const VkPipelineExecutablePropertiesKHR* in_struct);
+    void initialize(const safe_VkPipelineExecutablePropertiesKHR* src);
+    VkPipelineExecutablePropertiesKHR *ptr() { return reinterpret_cast<VkPipelineExecutablePropertiesKHR *>(this); }
+    VkPipelineExecutablePropertiesKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutablePropertiesKHR const *>(this); }
+};
+
+struct safe_VkPipelineExecutableInfoKHR {
+    VkStructureType sType;
+    const void* pNext;
+    VkPipeline pipeline;
+    uint32_t executableIndex;
+    safe_VkPipelineExecutableInfoKHR(const VkPipelineExecutableInfoKHR* in_struct);
+    safe_VkPipelineExecutableInfoKHR(const safe_VkPipelineExecutableInfoKHR& src);
+    safe_VkPipelineExecutableInfoKHR& operator=(const safe_VkPipelineExecutableInfoKHR& src);
+    safe_VkPipelineExecutableInfoKHR();
+    ~safe_VkPipelineExecutableInfoKHR();
+    void initialize(const VkPipelineExecutableInfoKHR* in_struct);
+    void initialize(const safe_VkPipelineExecutableInfoKHR* src);
+    VkPipelineExecutableInfoKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInfoKHR *>(this); }
+    VkPipelineExecutableInfoKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInfoKHR const *>(this); }
+};
+
+struct safe_VkPipelineExecutableStatisticKHR {
+    VkStructureType sType;
+    void* pNext;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkPipelineExecutableStatisticFormatKHR format;
+    VkPipelineExecutableStatisticValueKHR value;
+    safe_VkPipelineExecutableStatisticKHR(const VkPipelineExecutableStatisticKHR* in_struct);
+    safe_VkPipelineExecutableStatisticKHR(const safe_VkPipelineExecutableStatisticKHR& src);
+    safe_VkPipelineExecutableStatisticKHR& operator=(const safe_VkPipelineExecutableStatisticKHR& src);
+    safe_VkPipelineExecutableStatisticKHR();
+    ~safe_VkPipelineExecutableStatisticKHR();
+    void initialize(const VkPipelineExecutableStatisticKHR* in_struct);
+    void initialize(const safe_VkPipelineExecutableStatisticKHR* src);
+    VkPipelineExecutableStatisticKHR *ptr() { return reinterpret_cast<VkPipelineExecutableStatisticKHR *>(this); }
+    VkPipelineExecutableStatisticKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableStatisticKHR const *>(this); }
+};
+
+struct safe_VkPipelineExecutableInternalRepresentationKHR {
+    VkStructureType sType;
+    void* pNext;
+    char name[VK_MAX_DESCRIPTION_SIZE];
+    char description[VK_MAX_DESCRIPTION_SIZE];
+    VkBool32 isText;
+    size_t dataSize;
+    void* pData;
+    safe_VkPipelineExecutableInternalRepresentationKHR(const VkPipelineExecutableInternalRepresentationKHR* in_struct);
+    safe_VkPipelineExecutableInternalRepresentationKHR(const safe_VkPipelineExecutableInternalRepresentationKHR& src);
+    safe_VkPipelineExecutableInternalRepresentationKHR& operator=(const safe_VkPipelineExecutableInternalRepresentationKHR& src);
+    safe_VkPipelineExecutableInternalRepresentationKHR();
+    ~safe_VkPipelineExecutableInternalRepresentationKHR();
+    void initialize(const VkPipelineExecutableInternalRepresentationKHR* in_struct);
+    void initialize(const safe_VkPipelineExecutableInternalRepresentationKHR* src);
+    VkPipelineExecutableInternalRepresentationKHR *ptr() { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR *>(this); }
+    VkPipelineExecutableInternalRepresentationKHR const *ptr() const { return reinterpret_cast<VkPipelineExecutableInternalRepresentationKHR const *>(this); }
+};
+
 struct safe_VkDebugReportCallbackCreateInfoEXT {
     VkStructureType sType;
     const void* pNext;
@@ -3769,6 +3846,21 @@ struct safe_VkViSurfaceCreateInfoNN {
 };
 #endif // VK_USE_PLATFORM_VI_NN
 
+struct safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
+    VkStructureType sType;
+    const void* pNext;
+    VkBool32 textureCompressionASTC_HDR;
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct);
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src);
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& operator=(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT& src);
+    safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT();
+    ~safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT();
+    void initialize(const VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* in_struct);
+    void initialize(const safe_VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT* src);
+    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT *>(this); }
+    VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT const *>(this); }
+};
+
 struct safe_VkImageViewASTCDecodeModeEXT {
     VkStructureType sType;
     const void* pNext;
@@ -5443,6 +5535,21 @@ struct safe_VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
     VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceExternalMemoryHostPropertiesEXT const *>(this); }
 };
 
+struct safe_VkPipelineCompilerControlCreateInfoAMD {
+    VkStructureType sType;
+    const void* pNext;
+    VkPipelineCompilerControlFlagsAMD compilerControlFlags;
+    safe_VkPipelineCompilerControlCreateInfoAMD(const VkPipelineCompilerControlCreateInfoAMD* in_struct);
+    safe_VkPipelineCompilerControlCreateInfoAMD(const safe_VkPipelineCompilerControlCreateInfoAMD& src);
+    safe_VkPipelineCompilerControlCreateInfoAMD& operator=(const safe_VkPipelineCompilerControlCreateInfoAMD& src);
+    safe_VkPipelineCompilerControlCreateInfoAMD();
+    ~safe_VkPipelineCompilerControlCreateInfoAMD();
+    void initialize(const VkPipelineCompilerControlCreateInfoAMD* in_struct);
+    void initialize(const safe_VkPipelineCompilerControlCreateInfoAMD* src);
+    VkPipelineCompilerControlCreateInfoAMD *ptr() { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD *>(this); }
+    VkPipelineCompilerControlCreateInfoAMD const *ptr() const { return reinterpret_cast<VkPipelineCompilerControlCreateInfoAMD const *>(this); }
+};
+
 struct safe_VkCalibratedTimestampInfoEXT {
     VkStructureType sType;
     const void* pNext;
@@ -5733,19 +5840,19 @@ struct safe_VkCheckpointDataNV {
     VkCheckpointDataNV const *ptr() const { return reinterpret_cast<VkCheckpointDataNV const *>(this); }
 };
 
-struct safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL {
+struct safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
     VkStructureType sType;
     void* pNext;
     VkBool32 shaderIntegerFunctions2;
-    safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL(const VkPhysicalDeviceShaderIntegerFunctions2INTEL* in_struct);
-    safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL(const safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL& src);
-    safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL& operator=(const safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL& src);
-    safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL();
-    ~safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL();
-    void initialize(const VkPhysicalDeviceShaderIntegerFunctions2INTEL* in_struct);
-    void initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2INTEL* src);
-    VkPhysicalDeviceShaderIntegerFunctions2INTEL *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2INTEL *>(this); }
-    VkPhysicalDeviceShaderIntegerFunctions2INTEL const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2INTEL const *>(this); }
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct);
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& src);
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& operator=(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& src);
+    safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
+    ~safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL();
+    void initialize(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* in_struct);
+    void initialize(const safe_VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL* src);
+    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *>(this); }
+    VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL const *>(this); }
 };
 
 struct safe_VkPerformanceValueDataINTEL {
@@ -6005,6 +6112,86 @@ struct safe_VkPhysicalDeviceScalarBlockLayoutFeaturesEXT {
     VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeaturesEXT const *>(this); }
 };
 
+struct safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT {
+    VkStructureType sType;
+    void* pNext;
+    VkBool32 subgroupSizeControl;
+    VkBool32 computeFullSubgroups;
+    safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct);
+    safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& src);
+    safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT& src);
+    safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT();
+    ~safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT();
+    void initialize(const VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* in_struct);
+    void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlFeaturesEXT* src);
+    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT *>(this); }
+    VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT {
+    VkStructureType sType;
+    void* pNext;
+    uint32_t minSubgroupSize;
+    uint32_t maxSubgroupSize;
+    uint32_t maxComputeWorkgroupSubgroups;
+    VkShaderStageFlags requiredSubgroupSizeStages;
+    safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct);
+    safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& src);
+    safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& operator=(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT& src);
+    safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT();
+    ~safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT();
+    void initialize(const VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* in_struct);
+    void initialize(const safe_VkPhysicalDeviceSubgroupSizeControlPropertiesEXT* src);
+    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT *>(this); }
+    VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT const *>(this); }
+};
+
+struct safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
+    VkStructureType sType;
+    void* pNext;
+    uint32_t requiredSubgroupSize;
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct);
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& src);
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& operator=(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT& src);
+    safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT();
+    ~safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT();
+    void initialize(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* in_struct);
+    void initialize(const safe_VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT* src);
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT *>(this); }
+    VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceShaderCoreProperties2AMD {
+    VkStructureType sType;
+    void* pNext;
+    VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;
+    uint32_t activeComputeUnitCount;
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct);
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& src);
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD& operator=(const safe_VkPhysicalDeviceShaderCoreProperties2AMD& src);
+    safe_VkPhysicalDeviceShaderCoreProperties2AMD();
+    ~safe_VkPhysicalDeviceShaderCoreProperties2AMD();
+    void initialize(const VkPhysicalDeviceShaderCoreProperties2AMD* in_struct);
+    void initialize(const safe_VkPhysicalDeviceShaderCoreProperties2AMD* src);
+    VkPhysicalDeviceShaderCoreProperties2AMD *ptr() { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD *>(this); }
+    VkPhysicalDeviceShaderCoreProperties2AMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceShaderCoreProperties2AMD const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD {
+    VkStructureType sType;
+    void* pNext;
+    VkBool32 deviceCoherentMemory;
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct);
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& src);
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& operator=(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD& src);
+    safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD();
+    ~safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD();
+    void initialize(const VkPhysicalDeviceCoherentMemoryFeaturesAMD* in_struct);
+    void initialize(const safe_VkPhysicalDeviceCoherentMemoryFeaturesAMD* src);
+    VkPhysicalDeviceCoherentMemoryFeaturesAMD *ptr() { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD *>(this); }
+    VkPhysicalDeviceCoherentMemoryFeaturesAMD const *ptr() const { return reinterpret_cast<VkPhysicalDeviceCoherentMemoryFeaturesAMD const *>(this); }
+};
+
 struct safe_VkPhysicalDeviceMemoryBudgetPropertiesEXT {
     VkStructureType sType;
     void* pNext;
@@ -6346,6 +6533,59 @@ struct safe_VkHeadlessSurfaceCreateInfoEXT {
     VkHeadlessSurfaceCreateInfoEXT const *ptr() const { return reinterpret_cast<VkHeadlessSurfaceCreateInfoEXT const *>(this); }
 };
 
+struct safe_VkPhysicalDeviceLineRasterizationFeaturesEXT {
+    VkStructureType sType;
+    void* pNext;
+    VkBool32 rectangularLines;
+    VkBool32 bresenhamLines;
+    VkBool32 smoothLines;
+    VkBool32 stippledRectangularLines;
+    VkBool32 stippledBresenhamLines;
+    VkBool32 stippledSmoothLines;
+    safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct);
+    safe_VkPhysicalDeviceLineRasterizationFeaturesEXT(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& src);
+    safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& operator=(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT& src);
+    safe_VkPhysicalDeviceLineRasterizationFeaturesEXT();
+    ~safe_VkPhysicalDeviceLineRasterizationFeaturesEXT();
+    void initialize(const VkPhysicalDeviceLineRasterizationFeaturesEXT* in_struct);
+    void initialize(const safe_VkPhysicalDeviceLineRasterizationFeaturesEXT* src);
+    VkPhysicalDeviceLineRasterizationFeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>(this); }
+    VkPhysicalDeviceLineRasterizationFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT const *>(this); }
+};
+
+struct safe_VkPhysicalDeviceLineRasterizationPropertiesEXT {
+    VkStructureType sType;
+    void* pNext;
+    uint32_t lineSubPixelPrecisionBits;
+    safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct);
+    safe_VkPhysicalDeviceLineRasterizationPropertiesEXT(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& src);
+    safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& operator=(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT& src);
+    safe_VkPhysicalDeviceLineRasterizationPropertiesEXT();
+    ~safe_VkPhysicalDeviceLineRasterizationPropertiesEXT();
+    void initialize(const VkPhysicalDeviceLineRasterizationPropertiesEXT* in_struct);
+    void initialize(const safe_VkPhysicalDeviceLineRasterizationPropertiesEXT* src);
+    VkPhysicalDeviceLineRasterizationPropertiesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT *>(this); }
+    VkPhysicalDeviceLineRasterizationPropertiesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceLineRasterizationPropertiesEXT const *>(this); }
+};
+
+struct safe_VkPipelineRasterizationLineStateCreateInfoEXT {
+    VkStructureType sType;
+    const void* pNext;
+    VkLineRasterizationModeEXT lineRasterizationMode;
+    VkBool32 stippledLineEnable;
+    uint32_t lineStippleFactor;
+    uint16_t lineStipplePattern;
+    safe_VkPipelineRasterizationLineStateCreateInfoEXT(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct);
+    safe_VkPipelineRasterizationLineStateCreateInfoEXT(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& src);
+    safe_VkPipelineRasterizationLineStateCreateInfoEXT& operator=(const safe_VkPipelineRasterizationLineStateCreateInfoEXT& src);
+    safe_VkPipelineRasterizationLineStateCreateInfoEXT();
+    ~safe_VkPipelineRasterizationLineStateCreateInfoEXT();
+    void initialize(const VkPipelineRasterizationLineStateCreateInfoEXT* in_struct);
+    void initialize(const safe_VkPipelineRasterizationLineStateCreateInfoEXT* src);
+    VkPipelineRasterizationLineStateCreateInfoEXT *ptr() { return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT *>(this); }
+    VkPipelineRasterizationLineStateCreateInfoEXT const *ptr() const { return reinterpret_cast<VkPipelineRasterizationLineStateCreateInfoEXT const *>(this); }
+};
+
 struct safe_VkPhysicalDeviceHostQueryResetFeaturesEXT {
     VkStructureType sType;
     void* pNext;
@@ -6361,6 +6601,21 @@ struct safe_VkPhysicalDeviceHostQueryResetFeaturesEXT {
     VkPhysicalDeviceHostQueryResetFeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceHostQueryResetFeaturesEXT const *>(this); }
 };
 
+struct safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
+    VkStructureType sType;
+    void* pNext;
+    VkBool32 indexTypeUint8;
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct);
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& src);
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& operator=(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT& src);
+    safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT();
+    ~safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT();
+    void initialize(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT* in_struct);
+    void initialize(const safe_VkPhysicalDeviceIndexTypeUint8FeaturesEXT* src);
+    VkPhysicalDeviceIndexTypeUint8FeaturesEXT *ptr() { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT *>(this); }
+    VkPhysicalDeviceIndexTypeUint8FeaturesEXT const *ptr() const { return reinterpret_cast<VkPhysicalDeviceIndexTypeUint8FeaturesEXT const *>(this); }
+};
+
 struct safe_VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
     VkStructureType sType;
     void* pNext;
diff --git a/layers/generated/vk_typemap_helper.h b/layers/generated/vk_typemap_helper.h
index dc1d3a37b..257be53c8 100644
--- a/layers/generated/vk_typemap_helper.h
+++ b/layers/generated/vk_typemap_helper.h
@@ -1354,13 +1354,13 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR
     typedef VkPhysicalDevicePushDescriptorPropertiesKHR Type;
 };
 
-// Map type VkPhysicalDeviceFloat16Int8FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR
-template <> struct LvlTypeMap<VkPhysicalDeviceFloat16Int8FeaturesKHR> {
-    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR;
+// Map type VkPhysicalDeviceShaderFloat16Int8FeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR
+template <> struct LvlTypeMap<VkPhysicalDeviceShaderFloat16Int8FeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR;
 };
 
-template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR> {
-    typedef VkPhysicalDeviceFloat16Int8FeaturesKHR Type;
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR> {
+    typedef VkPhysicalDeviceShaderFloat16Int8FeaturesKHR Type;
 };
 
 // Map type VkPresentRegionsKHR to id VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR
@@ -1693,6 +1693,60 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_
     typedef VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR Type;
 };
 
+// Map type VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR
+template <> struct LvlTypeMap<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR> {
+    typedef VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR Type;
+};
+
+// Map type VkPipelineInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR
+template <> struct LvlTypeMap<VkPipelineInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR> {
+    typedef VkPipelineInfoKHR Type;
+};
+
+// Map type VkPipelineExecutablePropertiesKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR
+template <> struct LvlTypeMap<VkPipelineExecutablePropertiesKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR> {
+    typedef VkPipelineExecutablePropertiesKHR Type;
+};
+
+// Map type VkPipelineExecutableInfoKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR
+template <> struct LvlTypeMap<VkPipelineExecutableInfoKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR> {
+    typedef VkPipelineExecutableInfoKHR Type;
+};
+
+// Map type VkPipelineExecutableStatisticKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR
+template <> struct LvlTypeMap<VkPipelineExecutableStatisticKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR> {
+    typedef VkPipelineExecutableStatisticKHR Type;
+};
+
+// Map type VkPipelineExecutableInternalRepresentationKHR to id VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR
+template <> struct LvlTypeMap<VkPipelineExecutableInternalRepresentationKHR> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR> {
+    typedef VkPipelineExecutableInternalRepresentationKHR Type;
+};
+
 // Map type VkDebugReportCallbackCreateInfoEXT to id VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT
 template <> struct LvlTypeMap<VkDebugReportCallbackCreateInfoEXT> {
     static const VkStructureType kSType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
@@ -1901,6 +1955,15 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN> {
 };
 
 #endif // VK_USE_PLATFORM_VI_NN
+// Map type VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT
+template <> struct LvlTypeMap<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT> {
+    typedef VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT Type;
+};
+
 // Map type VkImageViewASTCDecodeModeEXT to id VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT
 template <> struct LvlTypeMap<VkImageViewASTCDecodeModeEXT> {
     static const VkStructureType kSType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT;
@@ -2754,6 +2817,15 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY
     typedef VkPhysicalDeviceExternalMemoryHostPropertiesEXT Type;
 };
 
+// Map type VkPipelineCompilerControlCreateInfoAMD to id VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD
+template <> struct LvlTypeMap<VkPipelineCompilerControlCreateInfoAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD> {
+    typedef VkPipelineCompilerControlCreateInfoAMD Type;
+};
+
 // Map type VkCalibratedTimestampInfoEXT to id VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT
 template <> struct LvlTypeMap<VkCalibratedTimestampInfoEXT> {
     static const VkStructureType kSType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT;
@@ -2909,13 +2981,13 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV> {
     typedef VkCheckpointDataNV Type;
 };
 
-// Map type VkPhysicalDeviceShaderIntegerFunctions2INTEL to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL
-template <> struct LvlTypeMap<VkPhysicalDeviceShaderIntegerFunctions2INTEL> {
-    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL;
+// Map type VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL
+template <> struct LvlTypeMap<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL;
 };
 
-template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL> {
-    typedef VkPhysicalDeviceShaderIntegerFunctions2INTEL Type;
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL> {
+    typedef VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL Type;
 };
 
 // Map type VkInitializePerformanceApiInfoINTEL to id VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL
@@ -3057,6 +3129,51 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LA
     typedef VkPhysicalDeviceScalarBlockLayoutFeaturesEXT Type;
 };
 
+// Map type VkPhysicalDeviceSubgroupSizeControlFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT
+template <> struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT> {
+    typedef VkPhysicalDeviceSubgroupSizeControlFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceSubgroupSizeControlPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT
+template <> struct LvlTypeMap<VkPhysicalDeviceSubgroupSizeControlPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceSubgroupSizeControlPropertiesEXT Type;
+};
+
+// Map type VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT
+template <> struct LvlTypeMap<VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT> {
+    typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT Type;
+};
+
+// Map type VkPhysicalDeviceShaderCoreProperties2AMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD
+template <> struct LvlTypeMap<VkPhysicalDeviceShaderCoreProperties2AMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD> {
+    typedef VkPhysicalDeviceShaderCoreProperties2AMD Type;
+};
+
+// Map type VkPhysicalDeviceCoherentMemoryFeaturesAMD to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD
+template <> struct LvlTypeMap<VkPhysicalDeviceCoherentMemoryFeaturesAMD> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD> {
+    typedef VkPhysicalDeviceCoherentMemoryFeaturesAMD Type;
+};
+
 // Map type VkPhysicalDeviceMemoryBudgetPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT
 template <> struct LvlTypeMap<VkPhysicalDeviceMemoryBudgetPropertiesEXT> {
     static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT;
@@ -3252,6 +3369,33 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EX
     typedef VkHeadlessSurfaceCreateInfoEXT Type;
 };
 
+// Map type VkPhysicalDeviceLineRasterizationFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT
+template <> struct LvlTypeMap<VkPhysicalDeviceLineRasterizationFeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT> {
+    typedef VkPhysicalDeviceLineRasterizationFeaturesEXT Type;
+};
+
+// Map type VkPhysicalDeviceLineRasterizationPropertiesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT
+template <> struct LvlTypeMap<VkPhysicalDeviceLineRasterizationPropertiesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT> {
+    typedef VkPhysicalDeviceLineRasterizationPropertiesEXT Type;
+};
+
+// Map type VkPipelineRasterizationLineStateCreateInfoEXT to id VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT
+template <> struct LvlTypeMap<VkPipelineRasterizationLineStateCreateInfoEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT> {
+    typedef VkPipelineRasterizationLineStateCreateInfoEXT Type;
+};
+
 // Map type VkPhysicalDeviceHostQueryResetFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT
 template <> struct LvlTypeMap<VkPhysicalDeviceHostQueryResetFeaturesEXT> {
     static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT;
@@ -3261,6 +3405,15 @@ template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESE
     typedef VkPhysicalDeviceHostQueryResetFeaturesEXT Type;
 };
 
+// Map type VkPhysicalDeviceIndexTypeUint8FeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT
+template <> struct LvlTypeMap<VkPhysicalDeviceIndexTypeUint8FeaturesEXT> {
+    static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT;
+};
+
+template <> struct LvlSTypeMap<VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT> {
+    typedef VkPhysicalDeviceIndexTypeUint8FeaturesEXT Type;
+};
+
 // Map type VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT to id VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT
 template <> struct LvlTypeMap<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT> {
     static const VkStructureType kSType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT;
diff --git a/layers/generated/vk_validation_error_messages.h b/layers/generated/vk_validation_error_messages.h
index 17dea3ca2..f8b9e1d1d 100644
--- a/layers/generated/vk_validation_error_messages.h
+++ b/layers/generated/vk_validation_error_messages.h
@@ -1,5 +1,5 @@
 /* THIS FILE IS GENERATED - DO NOT EDIT (scripts/vk_validation_stats.py) */
-/* Vulkan specification version: 1.1.114 */
+/* Vulkan specification version: 1.1.121 */
 /*
  * Vulkan
  *
@@ -42,12 +42,15 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkAccelerationStructureInfoNV-flags-parameter", "flags must be a valid combination of VkBuildAccelerationStructureFlagBitsNV values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-flags-parameter)"},
     {"VUID-VkAccelerationStructureInfoNV-geometryCount-02422", "geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-geometryCount-02422)"},
     {"VUID-VkAccelerationStructureInfoNV-instanceCount-02423", "instanceCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxInstanceCount (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-instanceCount-02423)"},
+    {"VUID-VkAccelerationStructureInfoNV-instanceData-02782", "If instanceData is not VK_NULL_HANDLE, instanceData must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-instanceData-02782)"},
     {"VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424", "The total number of triangles in all geometries must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxTriangleCount (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424)"},
     {"VUID-VkAccelerationStructureInfoNV-pGeometries-parameter", "If geometryCount is not 0, pGeometries must be a valid pointer to an array of geometryCount valid VkGeometryNV structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-pGeometries-parameter)"},
     {"VUID-VkAccelerationStructureInfoNV-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-pNext-pNext)"},
     {"VUID-VkAccelerationStructureInfoNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-sType-sType)"},
+    {"VUID-VkAccelerationStructureInfoNV-scratch-02781", "scratch must have been created with VK_BUFFER_USAGE_RAY_TRACING_BIT_NV usage flag (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-scratch-02781)"},
     {"VUID-VkAccelerationStructureInfoNV-type-02425", "If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV then geometryCount must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-type-02425)"},
     {"VUID-VkAccelerationStructureInfoNV-type-02426", "If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then instanceCount must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-type-02426)"},
+    {"VUID-VkAccelerationStructureInfoNV-type-02786", "If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then the geometryType member of each geometry in pGeometries must be the same (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-type-02786)"},
     {"VUID-VkAccelerationStructureInfoNV-type-parameter", "type must be a valid VkAccelerationStructureTypeNV value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureInfoNV-type-parameter)"},
     {"VUID-VkAccelerationStructureMemoryRequirementsInfoNV-accelerationStructure-parameter", "accelerationStructure must be a valid VkAccelerationStructureNV handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureMemoryRequirementsInfoNV-accelerationStructure-parameter)"},
     {"VUID-VkAccelerationStructureMemoryRequirementsInfoNV-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkAccelerationStructureMemoryRequirementsInfoNV-pNext-pNext)"},
@@ -132,8 +135,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkBindBufferMemoryInfo-buffer-01604", "If buffer was not created with VkDedicatedAllocationBufferCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-01604)"},
     {"VUID-VkBindBufferMemoryInfo-buffer-parameter", "buffer must be a valid VkBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-buffer-parameter)"},
     {"VUID-VkBindBufferMemoryInfo-commonparent", "Both of buffer, and memory must have been created, allocated, or retrieved from the same VkDevice (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-commonparent)"},
+    {"VUID-VkBindBufferMemoryInfo-handleTypes-02791", "If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryImageCreateInfo::handleTypes when image was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-handleTypes-02791)"},
     {"VUID-VkBindBufferMemoryInfo-memory-01599", "memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-01599)"},
     {"VUID-VkBindBufferMemoryInfo-memory-01900", "If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer and memoryOffset must be zero. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-01900)"},
+    {"VUID-VkBindBufferMemoryInfo-memory-02792", "If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-02792)"},
     {"VUID-VkBindBufferMemoryInfo-memory-parameter", "memory must be a valid VkDeviceMemory handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memory-parameter)"},
     {"VUID-VkBindBufferMemoryInfo-memoryOffset-01595", "memoryOffset must be less than the size of memory (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memoryOffset-01595)"},
     {"VUID-VkBindBufferMemoryInfo-memoryOffset-01600", "memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindBufferMemoryInfo-memoryOffset-01600)"},
@@ -154,12 +159,13 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-sType-sType)"},
     {"VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636", "splitInstanceBindRegionCount must either be zero or equal to the number of physical devices in the logical device squared (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryDeviceGroupInfo-splitInstanceBindRegionCount-01636)"},
     {"VUID-VkBindImageMemoryInfo-commonparent", "Both of image, and memory that are valid handles must have been created, allocated, or retrieved from the same VkDevice (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-commonparent)"},
+    {"VUID-VkBindImageMemoryInfo-handleTypes-02793", "If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryImageCreateInfo::handleTypes when image was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-handleTypes-02793)"},
     {"VUID-VkBindImageMemoryInfo-image-01609", "image must not already be backed by a memory object (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01609)"},
     {"VUID-VkBindImageMemoryInfo-image-01610", "image must not have been created with any sparse memory binding flags (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01610)"},
     {"VUID-VkBindImageMemoryInfo-image-01622", "If image requires a dedicated allocation (as reported by vkGetImageMemoryRequirements2 in VkMemoryDedicatedRequirements::requiresDedicatedAllocation for image), memory must have been created with VkMemoryDedicatedAllocateInfo::image equal to image and memoryOffset must be zero (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01622)"},
     {"VUID-VkBindImageMemoryInfo-image-01623", "If image was created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must have been created with VkDedicatedAllocationMemoryAllocateInfoNV::image equal to image and memoryOffset must be zero (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01623)"},
     {"VUID-VkBindImageMemoryInfo-image-01624", "If image was not created with VkDedicatedAllocationImageCreateInfoNV::dedicatedAllocation equal to VK_TRUE, memory must not have been allocated dedicated for a specific buffer or image (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01624)"},
-    {"VUID-VkBindImageMemoryInfo-image-01630", "If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01630)"},
+    {"VUID-VkBindImageMemoryInfo-image-01630", "If image was created with a valid swapchain handle in VkImageSwapchainCreateInfoKHR::swapchain, then the pNext chain must include a valid instance of VkBindImageMemorySwapchainInfoKHR containing the same swapchain handle. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-01630)"},
     {"VUID-VkBindImageMemoryInfo-image-parameter", "image must be a valid VkImage handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-image-parameter)"},
     {"VUID-VkBindImageMemoryInfo-memory-01612", "memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01612)"},
     {"VUID-VkBindImageMemoryInfo-memory-01614", "The difference of the size of memory and memoryOffset must be greater than or equal to the size member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with the same image (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01614)"},
@@ -167,6 +173,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkBindImageMemoryInfo-memory-01903", "If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-01903)"},
     {"VUID-VkBindImageMemoryInfo-memory-02630", "If the dedicated allocation image aliasing feature is not enabled, and the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-02630)"},
     {"VUID-VkBindImageMemoryInfo-memory-02631", "If the dedicated allocation image aliasing feature is enabled, and the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then memoryOffset must be zero, and image must be either equal to VkMemoryDedicatedAllocateInfo::image or an image that was created using the same parameters in VkImageCreateInfo, with the exception that extent and arrayLayers may differ subject to the following restrictions: every dimension in the extent parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created; and the arrayLayers parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-02631)"},
+    {"VUID-VkBindImageMemoryInfo-memory-02794", "If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memory-02794)"},
     {"VUID-VkBindImageMemoryInfo-memoryOffset-01611", "memoryOffset must be less than the size of memory (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memoryOffset-01611)"},
     {"VUID-VkBindImageMemoryInfo-memoryOffset-01613", "memoryOffset must be an integer multiple of the alignment member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-memoryOffset-01613)"},
     {"VUID-VkBindImageMemoryInfo-pNext-01615", "If the pNext chain does not include an instance of the VkBindImagePlaneMemoryInfo structure, memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements2 with image (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkBindImageMemoryInfo-pNext-01615)"},
@@ -367,7 +374,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056", "If the inherited queries feature is not enabled, occlusionQueryEnable must be VK_FALSE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056)"},
     {"VUID-VkCommandBufferInheritanceInfo-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkCommandBufferInheritanceConditionalRenderingInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-pNext-pNext)"},
     {"VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058", "If the pipeline statistics queries feature is not enabled, pipelineStatistics must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058)"},
+    {"VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789", "If the pipeline statistics queries feature is enabled, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789)"},
     {"VUID-VkCommandBufferInheritanceInfo-queryFlags-00057", "If the inherited queries feature is enabled, queryFlags must be a valid combination of VkQueryControlFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-queryFlags-00057)"},
+    {"VUID-VkCommandBufferInheritanceInfo-queryFlags-02788", "If the inherited queries feature is not enabled, queryFlags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-queryFlags-02788)"},
     {"VUID-VkCommandBufferInheritanceInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandBufferInheritanceInfo-sType-sType)"},
     {"VUID-VkCommandPoolCreateInfo-flags-parameter", "flags must be a valid combination of VkCommandPoolCreateFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandPoolCreateInfo-flags-parameter)"},
     {"VUID-VkCommandPoolCreateInfo-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCommandPoolCreateInfo-pNext-pNext)"},
@@ -385,8 +394,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkComputePipelineCreateInfo-layout-00703", "layout must be consistent with the layout of the compute shader specified in stage (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-00703)"},
     {"VUID-VkComputePipelineCreateInfo-layout-01687", "The number of resources in layout accessible to the compute shader stage must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-01687)"},
     {"VUID-VkComputePipelineCreateInfo-layout-parameter", "layout must be a valid VkPipelineLayout handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-layout-parameter)"},
-    {"VUID-VkComputePipelineCreateInfo-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineCreationFeedbackCreateInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-pNext-pNext)"},
+    {"VUID-VkComputePipelineCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCompilerControlCreateInfoAMD or VkPipelineCreationFeedbackCreateInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-pNext-pNext)"},
     {"VUID-VkComputePipelineCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-sType-sType)"},
+    {"VUID-VkComputePipelineCreateInfo-sType-unique", "Each sType member in the pNext chain must be unique (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-sType-unique)"},
     {"VUID-VkComputePipelineCreateInfo-stage-00701", "The stage member of stage must be VK_SHADER_STAGE_COMPUTE_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-00701)"},
     {"VUID-VkComputePipelineCreateInfo-stage-00702", "The shader code for the entry point identified by stage and the rest of the state identified by this structure must adhere to the pipeline linking rules described in the Shader Interfaces chapter (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-00702)"},
     {"VUID-VkComputePipelineCreateInfo-stage-parameter", "stage must be a valid VkPipelineShaderStageCreateInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkComputePipelineCreateInfo-stage-parameter)"},
@@ -410,6 +420,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkCopyDescriptorSet-dstBinding-00347", "dstBinding must be a valid binding within dstSet (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-dstBinding-00347)"},
     {"VUID-VkCopyDescriptorSet-dstBinding-02224", "If the descriptor type of the descriptor set binding specified by dstBinding is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, dstArrayElement must be an integer multiple of 4 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-dstBinding-02224)"},
     {"VUID-VkCopyDescriptorSet-dstBinding-02632", "The type of dstBinding within dstSet must be equal to the type of srcBinding within srcSet (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-dstBinding-02632)"},
+    {"VUID-VkCopyDescriptorSet-dstBinding-02753", "If the descriptor type of the descriptor set binding specified by dstBinding is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-dstBinding-02753)"},
     {"VUID-VkCopyDescriptorSet-dstSet-parameter", "dstSet must be a valid VkDescriptorSet handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-dstSet-parameter)"},
     {"VUID-VkCopyDescriptorSet-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-pNext-pNext)"},
     {"VUID-VkCopyDescriptorSet-sType-sType", "sType must be VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkCopyDescriptorSet-sType-sType)"},
@@ -584,7 +595,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkDeviceCreateInfo-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-flags-zerobitmask)"},
     {"VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter", "If pEnabledFeatures is not NULL, pEnabledFeatures must be a valid pointer to a valid VkPhysicalDeviceFeatures structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-pEnabledFeatures-parameter)"},
     {"VUID-VkDeviceCreateInfo-pNext-00373", "If the pNext chain includes a VkPhysicalDeviceFeatures2 structure, then pEnabledFeatures must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-00373)"},
-    {"VUID-VkDeviceCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFloat16Int8FeaturesKHR, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2INTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)"},
+    {"VUID-VkDeviceCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupDeviceCreateInfo, VkDeviceMemoryOverallocationCreateInfoAMD, VkPhysicalDevice16BitStorageFeatures, VkPhysicalDevice8BitStorageFeaturesKHR, VkPhysicalDeviceASTCDecodeFeaturesEXT, VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, VkPhysicalDeviceBufferDeviceAddressFeaturesEXT, VkPhysicalDeviceCoherentMemoryFeaturesAMD, VkPhysicalDeviceComputeShaderDerivativesFeaturesNV, VkPhysicalDeviceConditionalRenderingFeaturesEXT, VkPhysicalDeviceCooperativeMatrixFeaturesNV, VkPhysicalDeviceCornerSampledImageFeaturesNV, VkPhysicalDeviceCoverageReductionModeFeaturesNV, VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV, VkPhysicalDeviceDepthClipEnableFeaturesEXT, VkPhysicalDeviceDescriptorIndexingFeaturesEXT, VkPhysicalDeviceExclusiveScissorFeaturesNV, VkPhysicalDeviceFeatures2, VkPhysicalDeviceFragmentDensityMapFeaturesEXT, VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV, VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT, VkPhysicalDeviceHostQueryResetFeaturesEXT, VkPhysicalDeviceImagelessFramebufferFeaturesKHR, VkPhysicalDeviceIndexTypeUint8FeaturesEXT, VkPhysicalDeviceInlineUniformBlockFeaturesEXT, VkPhysicalDeviceLineRasterizationFeaturesEXT, VkPhysicalDeviceMemoryPriorityFeaturesEXT, VkPhysicalDeviceMeshShaderFeaturesNV, VkPhysicalDeviceMultiviewFeatures, VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR, VkPhysicalDeviceProtectedMemoryFeatures, VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV, VkPhysicalDeviceSamplerYcbcrConversionFeatures, VkPhysicalDeviceScalarBlockLayoutFeaturesEXT, VkPhysicalDeviceShaderAtomicInt64FeaturesKHR, VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, VkPhysicalDeviceShaderDrawParametersFeatures, VkPhysicalDeviceShaderFloat16Int8FeaturesKHR, VkPhysicalDeviceShaderImageFootprintFeaturesNV, VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL, VkPhysicalDeviceShaderSMBuiltinsFeaturesNV, VkPhysicalDeviceShadingRateImageFeaturesNV, VkPhysicalDeviceSubgroupSizeControlFeaturesEXT, VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT, VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT, VkPhysicalDeviceTransformFeedbackFeaturesEXT, VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR, VkPhysicalDeviceVariablePointersFeatures, VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT, VkPhysicalDeviceVulkanMemoryModelFeaturesKHR, or VkPhysicalDeviceYcbcrImageArraysFeaturesEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-pNext-pNext)"},
     {"VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter", "pQueueCreateInfos must be a valid pointer to an array of queueCreateInfoCount valid VkDeviceQueueCreateInfo structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-pQueueCreateInfos-parameter)"},
     {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374", "ppEnabledExtensionNames must not contain both VK_KHR_maintenance1 and VK_AMD_negative_viewport_height (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-00374)"},
     {"VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840", "ppEnabledExtensionNames must not contain VK_AMD_negative_viewport_height (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkDeviceCreateInfo-ppEnabledExtensionNames-01840)"},
@@ -786,6 +797,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkFramebufferAttachmentsCreateInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferAttachmentsCreateInfoKHR-sType-sType)"},
     {"VUID-VkFramebufferCreateInfo-attachmentCount-00876", "attachmentCount must be equal to the attachment count specified in renderPass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-attachmentCount-00876)"},
     {"VUID-VkFramebufferCreateInfo-commonparent", "Both of renderPass, and the elements of pAttachments that are valid handles must have been created, allocated, or retrieved from the same VkDevice (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-commonparent)"},
+    {"VUID-VkFramebufferCreateInfo-flags-02778", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, and attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-flags-02778)"},
     {"VUID-VkFramebufferCreateInfo-flags-03188", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, and attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-flags-03188)"},
     {"VUID-VkFramebufferCreateInfo-flags-03189", "If the imageless framebuffer feature is not enabled, flags must not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-flags-03189)"},
     {"VUID-VkFramebufferCreateInfo-flags-03190", "If flags includes VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, the pNext chain must include an instance of VkFramebufferAttachmentsCreateInfoKHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-flags-03190)"},
@@ -814,7 +826,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkFramebufferCreateInfo-pAttachments-00882", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00882)"},
     {"VUID-VkFramebufferCreateInfo-pAttachments-00883", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of pAttachments must only specify a single mip level (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00883)"},
     {"VUID-VkFramebufferCreateInfo-pAttachments-00884", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of pAttachments must have been created with the identity swizzle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00884)"},
-    {"VUID-VkFramebufferCreateInfo-pAttachments-00891", "Each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00891)"},
+    {"VUID-VkFramebufferCreateInfo-pAttachments-00891", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of pAttachments that is a 2D or 2D array image view taken from a 3D image must not be a depth/stencil format (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-00891)"},
     {"VUID-VkFramebufferCreateInfo-pAttachments-02552", "Each element of pAttachments that is used as a fragment density map attachment by renderPass must not have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-02552)"},
     {"VUID-VkFramebufferCreateInfo-pAttachments-02554", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of pAttachments must have dimensions at least as large as the corresponding framebuffer dimension except for any element that is referenced by fragmentDensityMapAttachment (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-02554)"},
     {"VUID-VkFramebufferCreateInfo-pAttachments-02555", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, an element of pAttachments that is referenced by fragmentDensityMapAttachment must have a width at least as large as the ceiling of width/maxFragmentDensityTexelSize.width (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-02555)"},
@@ -822,7 +834,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkFramebufferCreateInfo-pAttachments-02633", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of pAttachments that is used as a depth/stencil attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-02633)"},
     {"VUID-VkFramebufferCreateInfo-pAttachments-02634", "If flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of pAttachments that is used as a depth/stencil resolve attachment by renderPass must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-02634)"},
     {"VUID-VkFramebufferCreateInfo-pAttachments-02744", "An element of pAttachments that is referenced by fragmentDensityMapAttachment must have a layerCount equal to 1 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-02744)"},
-    {"VUID-VkFramebufferCreateInfo-pAttachments-parameter", "If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkImageView handles (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pAttachments-parameter)"},
     {"VUID-VkFramebufferCreateInfo-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkFramebufferAttachmentsCreateInfoKHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-pNext-pNext)"},
     {"VUID-VkFramebufferCreateInfo-renderPass-02531", "If renderPass was specified with non-zero view masks, layers must be 1 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-renderPass-02531)"},
     {"VUID-VkFramebufferCreateInfo-renderPass-02553", "If renderPass has a fragment density map attachment and non-subsample image feature is not enabled, each element of pAttachments must have been created with a flags value including VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT unless that element is the fragment density map attachment. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkFramebufferCreateInfo-renderPass-02553)"},
@@ -885,6 +896,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkGraphicsPipelineCreateInfo-layout-00756", "layout must be consistent with all shaders specified in pStages (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-00756)"},
     {"VUID-VkGraphicsPipelineCreateInfo-layout-01688", "The number of resources in layout accessible to each shader stage that is used by the pipeline must be less than or equal to VkPhysicalDeviceLimits::maxPerStageResources (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-01688)"},
     {"VUID-VkGraphicsPipelineCreateInfo-layout-parameter", "layout must be a valid VkPipelineLayout handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-layout-parameter)"},
+    {"VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766", "If the lineRasterizationMode member of a VkPipelineRasterizationLineStateCreateInfoEXT structure chained to the pNext chain of pRasterizationState is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT or VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT and if rasterization is enabled, then the alphaToCoverageEnable, alphaToOneEnable, and sampleShadingEnable members of pMultisampleState must all be VK_FALSE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter", "If pDynamicState is not NULL, pDynamicState must be a valid pointer to a valid VkPipelineDynamicStateCreateInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicState-parameter)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747", "If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT, the pViewports member of pViewportState must be a valid pointer to an array of pViewportState::viewportCount valid VkViewport structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00747)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748", "If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SCISSOR, the pScissors member of pViewportState must be a valid pointer to an array of pViewportState::scissorCount VkRect2D structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-00748)"},
@@ -896,7 +908,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523", "If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT, and the sampleLocationsEnable member of a VkPipelineSampleLocationsStateCreateInfoEXT structure chained to the pNext chain of pMultisampleState is VK_TRUE, sampleLocationsInfo.sampleLocationsPerPixel must equal rasterizationSamples (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01523)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715", "If no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV, and the viewportWScalingEnable member of a VkPipelineViewportWScalingStateCreateInfoNV structure, chained to the pNext chain of pViewportState, is VK_TRUE, the pViewportWScalings member of the VkPipelineViewportWScalingStateCreateInfoNV must be a pointer to an array of VkPipelineViewportWScalingStateCreateInfoNV::viewportCount valid VkViewportWScalingNV structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-01715)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-02510", "If the VK_EXT_depth_range_unrestricted extension is not enabled and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_DEPTH_BOUNDS, and the depthBoundsTestEnable member of pDepthStencilState is VK_TRUE, the minDepthBounds and maxDepthBounds members of pDepthStencilState must be between 0.0 and 1.0, inclusive (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pDynamicStates-02510)"},
-    {"VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCreationFeedbackCreateInfoEXT, VkPipelineDiscardRectangleStateCreateInfoEXT, or VkPipelineRepresentativeFragmentTestStateCreateInfoNV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)"},
+    {"VUID-VkGraphicsPipelineCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineCompilerControlCreateInfoAMD, VkPipelineCreationFeedbackCreateInfoEXT, VkPipelineDiscardRectangleStateCreateInfoEXT, or VkPipelineRepresentativeFragmentTestStateCreateInfoNV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pNext-pNext)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter", "pRasterizationState must be a valid pointer to a valid VkPipelineRasterizationStateCreateInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pRasterizationState-parameter)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pStages-00729", "If pStages includes a tessellation control shader stage, it must include a tessellation evaluation shader stage (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00729)"},
     {"VUID-VkGraphicsPipelineCreateInfo-pStages-00730", "If pStages includes a tessellation evaluation shader stage, it must include a tessellation control shader stage (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-pStages-00730)"},
@@ -937,6 +949,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkGraphicsPipelineCreateInfo-stage-00728", "The stage member of each element of pStages must not be VK_SHADER_STAGE_COMPUTE_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-00728)"},
     {"VUID-VkGraphicsPipelineCreateInfo-stage-02096", "The stage member of one element of pStages must be either VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_MESH_BIT_NV. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stage-02096)"},
     {"VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength", "stageCount must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stageCount-arraylength)"},
+    {"VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767", "If the stippledLineEnable member of VkPipelineRasterizationLineStateCreateInfoEXT is VK_TRUE and no element of the pDynamicStates member of pDynamicState is VK_DYNAMIC_STATE_LINE_STIPPLE_EXT, then the lineStippleFactor member of VkPipelineRasterizationLineStateCreateInfoEXT must be in the range [1,256] (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767)"},
     {"VUID-VkGraphicsPipelineCreateInfo-subpass-00743", "If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the depthWriteEnable member of pDepthStencilState must be VK_FALSE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00743)"},
     {"VUID-VkGraphicsPipelineCreateInfo-subpass-00744", "If rasterization is not disabled and subpass uses a depth/stencil attachment in renderPass that has a layout of VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL in the VkAttachmentReference defined by subpass, the failOp, passOp and depthFailOp members of each of the front and back members of pDepthStencilState must be VK_STENCIL_OP_KEEP (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00744)"},
     {"VUID-VkGraphicsPipelineCreateInfo-subpass-00757", "If neither the VK_AMD_mixed_attachment_samples nor the VK_NV_framebuffer_mixed_samples extensions are enabled, and if subpass uses color and/or depth/stencil attachments, then the rasterizationSamples member of pMultisampleState must be the same as the sample count for those subpass attachments (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkGraphicsPipelineCreateInfo-subpass-00757)"},
@@ -1126,7 +1139,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkImageCreateInfo-usage-requiredbitmask", "usage must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageCreateInfo-usage-requiredbitmask)"},
     {"VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-arrayPitch-02268", "For each element of pPlaneLayouts, arrayPitch must be 0 if VkImageCreateInfo::arrayLayers is 1. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-arrayPitch-02268)"},
     {"VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-depthPitch-02269", "For each element of pPlaneLayouts, depthPitch must be 0 if VkImageCreateInfo::extent::depth is 1. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-depthPitch-02269)"},
-    {"VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264", "drmFormatModifier must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2KHR extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264)"},
+    {"VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264", "drmFormatModifier must be compatible with the parameters in VkImageCreateInfo and its pNext chain, as determined by querying VkPhysicalDeviceImageFormatInfo2 extended with VkPhysicalDeviceImageDrmFormatModifierInfoEXT. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifier-02264)"},
     {"VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265", "drmFormatModifierPlaneCount must be equal to the VkDrmFormatModifierPropertiesEXT::drmFormatModifierPlaneCount associated with VkImageCreateInfo::format and drmFormatModifier, as found by querying VkDrmFormatModifierPropertiesListEXT. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-drmFormatModifierPlaneCount-02265)"},
     {"VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-pPlaneLayouts-parameter", "If drmFormatModifierPlaneCount is not 0, pPlaneLayouts must be a valid pointer to an array of drmFormatModifierPlaneCount VkSubresourceLayout structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-pPlaneLayouts-parameter)"},
     {"VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageDrmFormatModifierExplicitCreateInfoEXT-sType-sType)"},
@@ -1301,7 +1314,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkImageViewHandleInfoNVX-commonparent", "Both of imageView, and sampler that are valid handles must have been created, allocated, or retrieved from the same VkDevice (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-commonparent)"},
     {"VUID-VkImageViewHandleInfoNVX-descriptorType-02654", "descriptorType must be VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-descriptorType-02654)"},
     {"VUID-VkImageViewHandleInfoNVX-descriptorType-parameter", "descriptorType must be a valid VkDescriptorType value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-descriptorType-parameter)"},
-    {"VUID-VkImageViewHandleInfoNVX-imageView-02656", "If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the image that    imageView was created from must have been created with the    VK_IMAGE_USAGE_SAMPLED_BIT usage bit set (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-imageView-02656)"},
+    {"VUID-VkImageViewHandleInfoNVX-imageView-02656", "If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE or VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, the image that imageView was created from must have been created with the VK_IMAGE_USAGE_SAMPLED_BIT usage bit set (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-imageView-02656)"},
     {"VUID-VkImageViewHandleInfoNVX-imageView-02657", "If descriptorType is VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, the image that imageView was created from must have been created with the VK_IMAGE_USAGE_STORAGE_BIT usage bit set (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-imageView-02657)"},
     {"VUID-VkImageViewHandleInfoNVX-imageView-parameter", "imageView must be a valid VkImageView handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-imageView-parameter)"},
     {"VUID-VkImageViewHandleInfoNVX-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImageViewHandleInfoNVX-pNext-pNext)"},
@@ -1342,7 +1355,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkImportMemoryFdInfoKHR-handleType-00670", "If handleType is not 0, fd must be a valid handle of the type specified by handleType. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-00670)"},
     {"VUID-VkImportMemoryFdInfoKHR-handleType-parameter", "If handleType is not 0, handleType must be a valid VkExternalMemoryHandleTypeFlagBits value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-handleType-parameter)"},
     {"VUID-VkImportMemoryFdInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryFdInfoKHR-sType-sType)"},
-    {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747", "If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryPropertiesKHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747)"},
+    {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747", "If handleType is not 0, it must be supported for import, as reported in VkExternalMemoryProperties (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01747)"},
     {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748", "If handleType is not 0, it must be VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT or VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01748)"},
     {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750", "If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01750)"},
     {"VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751", "If handleType is VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT, pHostPointer must be a pointer to allocationSize number of bytes of host mapped foreign memory, where allocationSize is the member of the VkMemoryAllocateInfo structure this structure is chained to (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkImportMemoryHostPointerInfoEXT-handleType-01751)"},
@@ -1482,7 +1495,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkMemoryDedicatedRequirements-sType-sType", "sType must be VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryDedicatedRequirements-sType-sType)"},
     {"VUID-VkMemoryFdPropertiesKHR-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryFdPropertiesKHR-pNext-pNext)"},
     {"VUID-VkMemoryFdPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryFdPropertiesKHR-sType-sType)"},
-    {"VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882", "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfoKHR::handleTypes when memory was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882)"},
+    {"VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882", "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID must have been included in VkExportMemoryAllocateInfo::handleTypes when memory was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-handleTypes-01882)"},
     {"VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-memory-parameter", "memory must be a valid VkDeviceMemory handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-memory-parameter)"},
     {"VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883", "If the pNext chain of the VkMemoryAllocateInfo used to allocate memory included a VkMemoryDedicatedAllocateInfo with non-NULL image member, then that image must already be bound to memory. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-01883)"},
     {"VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkMemoryGetAndroidHardwareBufferInfoANDROID-pNext-pNext)"},
@@ -1540,6 +1553,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter", "buffer must be a valid VkBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-buffer-parameter)"},
     {"VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter", "flags must be a valid combination of VkObjectEntryUsageFlagBitsNVX values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-flags-parameter)"},
     {"VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask", "flags must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-flags-requiredbitmask)"},
+    {"VUID-VkObjectTableIndexBufferEntryNVX-indexType-02783", "indexType must be VK_INDEX_TYPE_UINT16, or VK_INDEX_TYPE_UINT32 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-indexType-02783)"},
     {"VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter", "indexType must be a valid VkIndexType value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-indexType-parameter)"},
     {"VUID-VkObjectTableIndexBufferEntryNVX-type-01371", "type must be VK_OBJECT_ENTRY_TYPE_INDEX_BUFFER_NVX (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-type-01371)"},
     {"VUID-VkObjectTableIndexBufferEntryNVX-type-parameter", "type must be a valid VkObjectEntryTypeNVX value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkObjectTableIndexBufferEntryNVX-type-parameter)"},
@@ -1580,6 +1594,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceBufferDeviceAddressFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceBufferDeviceAddressFeaturesEXT-sType-sType)"},
+    {"VUID-VkPhysicalDeviceCoherentMemoryFeaturesAMD-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceCoherentMemoryFeaturesAMD-sType-sType)"},
     {"VUID-VkPhysicalDeviceComputeShaderDerivativesFeaturesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceComputeShaderDerivativesFeaturesNV-sType-sType)"},
     {"VUID-VkPhysicalDeviceConditionalRenderingFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceConditionalRenderingFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceConservativeRasterizationPropertiesEXT-sType-sType)"},
@@ -1611,7 +1626,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-pNext-pNext)"},
     {"VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceExternalSemaphoreInfo-sType-sType)"},
     {"VUID-VkPhysicalDeviceFeatures2-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceFeatures2-sType-sType)"},
-    {"VUID-VkPhysicalDeviceFloat16Int8FeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceFloat16Int8FeaturesKHR-sType-sType)"},
     {"VUID-VkPhysicalDeviceFloatControlsPropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceFloatControlsPropertiesKHR-sType-sType)"},
     {"VUID-VkPhysicalDeviceFragmentDensityMapFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceFragmentDensityMapFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceFragmentDensityMapPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceFragmentDensityMapPropertiesEXT-sType-sType)"},
@@ -1640,14 +1654,16 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-imageViewType-parameter", "imageViewType must be a valid VkImageViewType value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-imageViewType-parameter)"},
     {"VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImageViewImageFormatInfoEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceImagelessFramebufferFeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceImagelessFramebufferFeaturesKHR-sType-sType)"},
+    {"VUID-VkPhysicalDeviceIndexTypeUint8FeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceIndexTypeUint8FeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceInlineUniformBlockFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceInlineUniformBlockFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceInlineUniformBlockPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceInlineUniformBlockPropertiesEXT-sType-sType)"},
+    {"VUID-VkPhysicalDeviceLineRasterizationFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceLineRasterizationFeaturesEXT-sType-sType)"},
+    {"VUID-VkPhysicalDeviceLineRasterizationPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceLineRasterizationPropertiesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMaintenance3Properties-sType-sType)"},
     {"VUID-VkPhysicalDeviceMemoryBudgetPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryBudgetPropertiesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceMemoryPriorityFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryPriorityFeaturesEXT-sType-sType)"},
-    {"VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceMemoryBudgetPropertiesEXT or VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext)"},
+    {"VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPhysicalDeviceMemoryBudgetPropertiesEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-pNext-pNext)"},
     {"VUID-VkPhysicalDeviceMemoryProperties2-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-sType-sType)"},
-    {"VUID-VkPhysicalDeviceMemoryProperties2-sType-unique", "Each sType member in the pNext chain must be unique (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMemoryProperties2-sType-unique)"},
     {"VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMeshShaderFeaturesNV-sType-sType)"},
     {"VUID-VkPhysicalDeviceMeshShaderPropertiesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMeshShaderPropertiesNV-sType-sType)"},
     {"VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580", "If multiviewGeometryShader is enabled then multiview must also be enabled. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewFeatures-multiviewGeometryShader-00580)"},
@@ -1656,8 +1672,9 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX-sType-sType)"},
     {"VUID-VkPhysicalDeviceMultiviewProperties-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceMultiviewProperties-sType-sType)"},
     {"VUID-VkPhysicalDevicePCIBusInfoPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDevicePCIBusInfoPropertiesEXT-sType-sType)"},
+    {"VUID-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR-sType-sType)"},
     {"VUID-VkPhysicalDevicePointClippingProperties-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDevicePointClippingProperties-sType-sType)"},
-    {"VUID-VkPhysicalDeviceProperties2-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceDepthStencilResolvePropertiesKHR, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsPropertiesKHR, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-pNext-pNext)"},
+    {"VUID-VkPhysicalDeviceProperties2-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT, VkPhysicalDeviceConservativeRasterizationPropertiesEXT, VkPhysicalDeviceCooperativeMatrixPropertiesNV, VkPhysicalDeviceDepthStencilResolvePropertiesKHR, VkPhysicalDeviceDescriptorIndexingPropertiesEXT, VkPhysicalDeviceDiscardRectanglePropertiesEXT, VkPhysicalDeviceDriverPropertiesKHR, VkPhysicalDeviceExternalMemoryHostPropertiesEXT, VkPhysicalDeviceFloatControlsPropertiesKHR, VkPhysicalDeviceFragmentDensityMapPropertiesEXT, VkPhysicalDeviceIDProperties, VkPhysicalDeviceInlineUniformBlockPropertiesEXT, VkPhysicalDeviceLineRasterizationPropertiesEXT, VkPhysicalDeviceMaintenance3Properties, VkPhysicalDeviceMeshShaderPropertiesNV, VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX, VkPhysicalDeviceMultiviewProperties, VkPhysicalDevicePCIBusInfoPropertiesEXT, VkPhysicalDevicePointClippingProperties, VkPhysicalDeviceProtectedMemoryProperties, VkPhysicalDevicePushDescriptorPropertiesKHR, VkPhysicalDeviceRayTracingPropertiesNV, VkPhysicalDeviceSampleLocationsPropertiesEXT, VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT, VkPhysicalDeviceShaderCoreProperties2AMD, VkPhysicalDeviceShaderCorePropertiesAMD, VkPhysicalDeviceShaderSMBuiltinsPropertiesNV, VkPhysicalDeviceShadingRateImagePropertiesNV, VkPhysicalDeviceSubgroupProperties, VkPhysicalDeviceSubgroupSizeControlPropertiesEXT, VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT, VkPhysicalDeviceTransformFeedbackPropertiesEXT, or VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-pNext-pNext)"},
     {"VUID-VkPhysicalDeviceProperties2-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-sType-sType)"},
     {"VUID-VkPhysicalDeviceProperties2-sType-unique", "Each sType member in the pNext chain must be unique (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProperties2-sType-unique)"},
     {"VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceProtectedMemoryFeatures-sType-sType)"},
@@ -1670,11 +1687,13 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSamplerYcbcrConversionFeatures-sType-sType)"},
     {"VUID-VkPhysicalDeviceScalarBlockLayoutFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceScalarBlockLayoutFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceShaderAtomicInt64FeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderAtomicInt64FeaturesKHR-sType-sType)"},
+    {"VUID-VkPhysicalDeviceShaderCoreProperties2AMD-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderCoreProperties2AMD-sType-sType)"},
     {"VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderCorePropertiesAMD-sType-sType)"},
     {"VUID-VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceShaderDrawParametersFeatures-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderDrawParametersFeatures-sType-sType)"},
+    {"VUID-VkPhysicalDeviceShaderFloat16Int8FeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderFloat16Int8FeaturesKHR-sType-sType)"},
     {"VUID-VkPhysicalDeviceShaderImageFootprintFeaturesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderImageFootprintFeaturesNV-sType-sType)"},
-    {"VUID-VkPhysicalDeviceShaderIntegerFunctions2INTEL-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS2_FEATURES_INTEL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderIntegerFunctions2INTEL-sType-sType)"},
+    {"VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL-sType-sType)"},
     {"VUID-VkPhysicalDeviceShaderSMBuiltinsFeaturesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderSMBuiltinsFeaturesNV-sType-sType)"},
     {"VUID-VkPhysicalDeviceShaderSMBuiltinsPropertiesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShaderSMBuiltinsPropertiesNV-sType-sType)"},
     {"VUID-VkPhysicalDeviceShadingRateImageFeaturesNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceShadingRateImageFeaturesNV-sType-sType)"},
@@ -1689,6 +1708,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter", "usage must be a valid combination of VkImageUsageFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-parameter)"},
     {"VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask", "usage must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSparseImageFormatInfo2-usage-requiredbitmask)"},
     {"VUID-VkPhysicalDeviceSubgroupProperties-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSubgroupProperties-sType-sType)"},
+    {"VUID-VkPhysicalDeviceSubgroupSizeControlFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSubgroupSizeControlFeaturesEXT-sType-sType)"},
+    {"VUID-VkPhysicalDeviceSubgroupSizeControlPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSubgroupSizeControlPropertiesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-02672", "If the pNext chain includes an instance of VkSurfaceFullScreenExclusiveInfoEXT with its fullScreenExclusive member set to VK_FULL_SCREEN_EXCLUSIVE_APPLICATION_CONTROLLED_EXT, and surface was created using vkCreateWin32SurfaceKHR, an instance of VkSurfaceFullScreenExclusiveWin32InfoEXT must be present in the pNext chain (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-02672)"},
     {"VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkSurfaceFullScreenExclusiveInfoEXT or VkSurfaceFullScreenExclusiveWin32InfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-pNext-pNext)"},
     {"VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-sType-sType)"},
@@ -1696,6 +1717,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter", "surface must be a valid VkSurfaceKHR handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceSurfaceInfo2KHR-surface-parameter)"},
     {"VUID-VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT-sType-sType)"},
+    {"VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceTransformFeedbackFeaturesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceTransformFeedbackFeaturesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceTransformFeedbackPropertiesEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceTransformFeedbackPropertiesEXT-sType-sType)"},
     {"VUID-VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR-sType-sType)"},
@@ -1739,6 +1761,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter", "If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkPipelineColorBlendAttachmentState structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pAttachments-parameter)"},
     {"VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineColorBlendAdvancedStateCreateInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-pNext-pNext)"},
     {"VUID-VkPipelineColorBlendStateCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineColorBlendStateCreateInfo-sType-sType)"},
+    {"VUID-VkPipelineCompilerControlCreateInfoAMD-compilerControlFlags-zerobitmask", "compilerControlFlags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineCompilerControlCreateInfoAMD-compilerControlFlags-zerobitmask)"},
+    {"VUID-VkPipelineCompilerControlCreateInfoAMD-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineCompilerControlCreateInfoAMD-sType-sType)"},
     {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter", "coverageModulationMode must be a valid VkCoverageModulationModeNV value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationMode-parameter)"},
     {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405", "If coverageModulationTableEnable is VK_TRUE, coverageModulationTableCount must be equal to the number of rasterization samples divided by the number of color samples in the subpass. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-coverageModulationTableEnable-01405)"},
     {"VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineCoverageModulationStateCreateInfoNV-flags-zerobitmask)"},
@@ -1772,6 +1796,22 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter", "If dynamicStateCount is not 0, pDynamicStates must be a valid pointer to an array of dynamicStateCount valid VkDynamicState values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pDynamicStates-parameter)"},
     {"VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-pNext-pNext)"},
     {"VUID-VkPipelineDynamicStateCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineDynamicStateCreateInfo-sType-sType)"},
+    {"VUID-VkPipelineExecutableInfoKHR-executableIndex-03275", "executableIndex must be less than the number of executables associated with pipeline as returned in the pExecutableCount parameter of vkGetPipelineExecutablePropertiesKHR. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInfoKHR-executableIndex-03275)"},
+    {"VUID-VkPipelineExecutableInfoKHR-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInfoKHR-pNext-pNext)"},
+    {"VUID-VkPipelineExecutableInfoKHR-pipeline-parameter", "pipeline must be a valid VkPipeline handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInfoKHR-pipeline-parameter)"},
+    {"VUID-VkPipelineExecutableInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInfoKHR-sType-sType)"},
+    {"VUID-VkPipelineExecutableInternalRepresentationKHR-description-parameter", "description must be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DESCRIPTION_SIZE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInternalRepresentationKHR-description-parameter)"},
+    {"VUID-VkPipelineExecutableInternalRepresentationKHR-name-parameter", "name must be a null-terminated UTF-8 string whose length is less than or equal to VK_MAX_DESCRIPTION_SIZE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInternalRepresentationKHR-name-parameter)"},
+    {"VUID-VkPipelineExecutableInternalRepresentationKHR-pData-parameter", "If dataSize is not 0, and pData is not NULL, pData must be a valid pointer to an array of dataSize bytes (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInternalRepresentationKHR-pData-parameter)"},
+    {"VUID-VkPipelineExecutableInternalRepresentationKHR-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInternalRepresentationKHR-pNext-pNext)"},
+    {"VUID-VkPipelineExecutableInternalRepresentationKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableInternalRepresentationKHR-sType-sType)"},
+    {"VUID-VkPipelineExecutablePropertiesKHR-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutablePropertiesKHR-pNext-pNext)"},
+    {"VUID-VkPipelineExecutablePropertiesKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutablePropertiesKHR-sType-sType)"},
+    {"VUID-VkPipelineExecutableStatisticKHR-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableStatisticKHR-pNext-pNext)"},
+    {"VUID-VkPipelineExecutableStatisticKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineExecutableStatisticKHR-sType-sType)"},
+    {"VUID-VkPipelineInfoKHR-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineInfoKHR-pNext-pNext)"},
+    {"VUID-VkPipelineInfoKHR-pipeline-parameter", "pipeline must be a valid VkPipeline handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineInfoKHR-pipeline-parameter)"},
+    {"VUID-VkPipelineInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineInfoKHR-sType-sType)"},
     {"VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask)"},
     {"VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext)"},
     {"VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType)"},
@@ -1852,11 +1892,20 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationConservativeStateCreateInfoEXT-sType-sType)"},
     {"VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-flags-zerobitmask)"},
     {"VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationDepthClipStateCreateInfoEXT-sType-sType)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768", "If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the rectangularLines feature must be enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769", "If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the bresenhamLines feature must be enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770", "If lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the smoothLines feature must be enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter", "lineRasterizationMode must be a valid VkLineRasterizationModeEXT value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-parameter)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-sType-sType)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771", "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT, then the stippledRectangularLines feature must be enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772", "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT, then the stippledBresenhamLines feature must be enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773", "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT, then the stippledSmoothLines feature must be enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773)"},
+    {"VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774", "If stippledLineEnable is VK_TRUE and lineRasterizationMode is VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT, then the stippledRectangularLines feature must be enabled and VkPhysicalDeviceLimits::strictLines must be VK_TRUE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774)"},
     {"VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter", "cullMode must be a valid combination of VkCullModeFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-cullMode-parameter)"},
     {"VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782", "If the depth clamping feature is not enabled, depthClampEnable must be VK_FALSE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-depthClampEnable-00782)"},
     {"VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-flags-zerobitmask)"},
     {"VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter", "frontFace must be a valid VkFrontFace value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-frontFace-parameter)"},
-    {"VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT, VkPipelineRasterizationStateRasterizationOrderAMD, or VkPipelineRasterizationStateStreamCreateInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext)"},
+    {"VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkPipelineRasterizationConservativeStateCreateInfoEXT, VkPipelineRasterizationDepthClipStateCreateInfoEXT, VkPipelineRasterizationLineStateCreateInfoEXT, VkPipelineRasterizationStateRasterizationOrderAMD, or VkPipelineRasterizationStateStreamCreateInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-pNext-pNext)"},
     {"VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413", "If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01413)"},
     {"VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414", "If the VK_NV_fill_rectangle extension is not enabled, polygonMode must not be VK_POLYGON_MODE_FILL_RECTANGLE_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414)"},
     {"VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", "If the non-solid fill modes feature is not enabled, polygonMode must be VK_POLYGON_MODE_FILL or VK_POLYGON_MODE_FILL_RECTANGLE_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507)"},
@@ -1873,7 +1922,11 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPipelineRepresentativeFragmentTestStateCreateInfoNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineRepresentativeFragmentTestStateCreateInfoNV-sType-sType)"},
     {"VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sType-sType)"},
     {"VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter", "sampleLocationsInfo must be a valid VkSampleLocationsInfoEXT structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineSampleLocationsStateCreateInfoEXT-sampleLocationsInfo-parameter)"},
-    {"VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-zerobitmask)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-flags-02758", "If flags has both the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT and VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flags set, the local workgroup size in the X dimension of the pipeline must be a multiple of maxSubgroupSize. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-02758)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-flags-02759", "If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set and flags does not have the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set and no VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is chained to pNext, the local workgroup size in the X dimension of the pipeline must be a multiple of subgroupSize. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-02759)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-flags-02784", "If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set, the subgroupSizeControl feature must be enabled. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-02784)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-flags-02785", "If flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set, the computeFullSubgroups feature must be enabled. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-02785)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-flags-parameter", "flags must be a valid combination of VkPipelineShaderStageCreateFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-flags-parameter)"},
     {"VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708", "If the identified entry point includes any variable in its interface that is declared with the ClipDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxClipDistances (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxClipDistances-00708)"},
     {"VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710", "If the identified entry point includes any variables in its interface that are declared with the ClipDistance or CullDistance BuiltIn decoration, those variables must not have array sizes which sum to more than VkPhysicalDeviceLimits::maxCombinedClipAndCullDistances (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxCombinedClipAndCullDistances-00710)"},
     {"VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709", "If the identified entry point includes any variable in its interface that is declared with the CullDistance BuiltIn decoration, that variable must not have an array size greater than VkPhysicalDeviceLimits::maxCullDistances (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-maxCullDistances-00709)"},
@@ -1881,7 +1934,11 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPipelineShaderStageCreateInfo-module-parameter", "module must be a valid VkShaderModule handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-module-parameter)"},
     {"VUID-VkPipelineShaderStageCreateInfo-pName-00707", "pName must be the name of an OpEntryPoint in module with an execution model that matches stage (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pName-00707)"},
     {"VUID-VkPipelineShaderStageCreateInfo-pName-parameter", "pName must be a null-terminated UTF-8 string (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pName-parameter)"},
-    {"VUID-VkPipelineShaderStageCreateInfo-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-pNext)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-pNext-02754", "If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is chained to pNext, flags must not have the VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT flag set. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-02754)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-pNext-02755", "If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is chained to pNext, the subgroupSizeControl feature must be enabled, and stage must be a valid bit specified in requiredSubgroupSizeStages. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-02755)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-pNext-02756", "If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is chained to pNext and stage is VK_SHADER_STAGE_COMPUTE_BIT then local workgroup size of the shader must be less than or equal to the product of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::requiredSubgroupSize and maxComputeWorkgroupSubgroups. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-02756)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-pNext-02757", "If a VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT structure is chained to pNext, and flags has the VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT flag set, the local workgroup size in the X dimension of the pipeline must be a multiple of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT::requiredSubgroupSize. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-02757)"},
+    {"VUID-VkPipelineShaderStageCreateInfo-pNext-pNext", "pNext must be NULL or a pointer to a valid instance of VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pNext-pNext)"},
     {"VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter", "If pSpecializationInfo is not NULL, pSpecializationInfo must be a valid pointer to a valid VkSpecializationInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-pSpecializationInfo-parameter)"},
     {"VUID-VkPipelineShaderStageCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-sType-sType)"},
     {"VUID-VkPipelineShaderStageCreateInfo-stage-00704", "If the geometry shaders feature is not enabled, stage must not be VK_SHADER_STAGE_GEOMETRY_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-00704)"},
@@ -1901,6 +1958,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPipelineShaderStageCreateInfo-stage-02596", "If stage is a vertex processing stage, and the identified entry point writes to Layer for any primitive, it must write the same value to Layer for all vertices of a given primitive (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-02596)"},
     {"VUID-VkPipelineShaderStageCreateInfo-stage-02597", "If stage is a vertex processing stage, and the identified entry point writes to ViewportIndex for any primitive, it must write the same value to ViewportIndex for all vertices of a given primitive (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-02597)"},
     {"VUID-VkPipelineShaderStageCreateInfo-stage-parameter", "stage must be a valid VkShaderStageFlagBits value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageCreateInfo-stage-parameter)"},
+    {"VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02760", "requiredSubgroupSize must be a power-of-two integer. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02760)"},
+    {"VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02761", "requiredSubgroupSize must be greater or equal to minSubgroupSize. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02761)"},
+    {"VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02762", "requiredSubgroupSize must be less than or equal to maxSubgroupSize. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-requiredSubgroupSize-02762)"},
+    {"VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT-sType-sType)"},
     {"VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter", "domainOrigin must be a valid VkTessellationDomainOrigin value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineTessellationDomainOriginStateCreateInfo-domainOrigin-parameter)"},
     {"VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType", "sType must be VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineTessellationDomainOriginStateCreateInfo-sType-sType)"},
     {"VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask)"},
@@ -1992,6 +2053,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkPushConstantRange-stageFlags-requiredbitmask", "stageFlags must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkPushConstantRange-stageFlags-requiredbitmask)"},
     {"VUID-VkQueryPoolCreateInfo-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkQueryPoolCreateInfo-flags-zerobitmask)"},
     {"VUID-VkQueryPoolCreateInfo-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkQueryPoolCreateInfo-pNext-pNext)"},
+    {"VUID-VkQueryPoolCreateInfo-queryCount-02763", "queryCount must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryCount-02763)"},
     {"VUID-VkQueryPoolCreateInfo-queryType-00791", "If the pipeline statistics queries feature is not enabled, queryType must not be VK_QUERY_TYPE_PIPELINE_STATISTICS (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-00791)"},
     {"VUID-VkQueryPoolCreateInfo-queryType-00792", "If queryType is VK_QUERY_TYPE_PIPELINE_STATISTICS, pipelineStatistics must be a valid combination of VkQueryPipelineStatisticFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-00792)"},
     {"VUID-VkQueryPoolCreateInfo-queryType-parameter", "queryType must be a valid VkQueryType value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkQueryPoolCreateInfo-queryType-parameter)"},
@@ -2037,20 +2099,20 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkRenderPassAttachmentBeginInfoKHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassAttachmentBeginInfoKHR-sType-sType)"},
     {"VUID-VkRenderPassBeginInfo-clearValueCount-00902", "clearValueCount must be greater than the largest attachment index in renderPass that specifies a loadOp (or stencilLoadOp, if the attachment has a depth/stencil format) of VK_ATTACHMENT_LOAD_OP_CLEAR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-clearValueCount-00902)"},
     {"VUID-VkRenderPassBeginInfo-commonparent", "Both of framebuffer, and renderPass must have been created, allocated, or retrieved from the same VkDevice (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-commonparent)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-02780", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must have been created on the same VkDevice as framebuffer and renderPass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-02780)"},
     {"VUID-VkRenderPassBeginInfo-framebuffer-03207", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that did not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, and the pNext chain includes an instance of VkRenderPassAttachmentBeginInfoKHR, its attachmentCount must be zero (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03207)"},
     {"VUID-VkRenderPassBeginInfo-framebuffer-03208", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, the attachmentCount of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be equal to the value of VkFramebufferAttachmentsCreateInfoKHR::attachmentImageInfoCount used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03208)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03209", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::flags equal to the flags member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03209)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03210", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::usage equal to the usage member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03210)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03211", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView with a width equal to the width member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03211)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03212", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView with a height equal to the height member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03212)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03213", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::subresourceRange.pname:layerCount equal to the layerCount member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03213)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03214", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageFormatListCreateInfoKHR::viewFormatCount equal to the viewFormatCount member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03214)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03215", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a set of elements in VkImageFormatListCreateInfoKHR::pViewFormats equal to the set of elements in the pViewFormats member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03215)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03216", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::format equal to the corresponding value of VkAttachmentDescription::format in renderPass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03216)"},
-    {"VUID-VkRenderPassBeginInfo-framebuffer-03217", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the attachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::samples equal to the corresponding value of VkAttachmentDescription::samples in renderPass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03217)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03209", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::flags equal to the flags member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03209)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03210", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::usage equal to the usage member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03210)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03211", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView with a width equal to the width member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03211)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03212", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView with a height equal to the height member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03212)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03213", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::subresourceRange.pname:layerCount equal to the layerCount member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03213)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03214", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageFormatListCreateInfoKHR::viewFormatCount equal to the viewFormatCount member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03214)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03215", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a set of elements in VkImageFormatListCreateInfoKHR::pViewFormats equal to the set of elements in the pViewFormats member of the corresponding element of VkFramebufferAttachmentsCreateInfoKHR::pAttachments used to create framebuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03215)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03216", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageViewCreateInfo::format equal to the corresponding value of VkAttachmentDescription::format in renderPass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03216)"},
+    {"VUID-VkRenderPassBeginInfo-framebuffer-03217", "If framebuffer was created with a VkFramebufferCreateInfo::flags value that included VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, each element of the pAttachments member of an instance of VkRenderPassAttachmentBeginInfoKHR included in the pNext chain must be a VkImageView of an image created with a value of VkImageCreateInfo::samples equal to the corresponding value of VkAttachmentDescription::samples in renderPass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-03217)"},
     {"VUID-VkRenderPassBeginInfo-framebuffer-parameter", "framebuffer must be a valid VkFramebuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-framebuffer-parameter)"},
     {"VUID-VkRenderPassBeginInfo-pClearValues-parameter", "If clearValueCount is not 0, pClearValues must be a valid pointer to an array of clearValueCount VkClearValue unions (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-pClearValues-parameter)"},
-    {"VUID-VkRenderPassBeginInfo-pNext-03206", "If the imageless framebuffer feature is not enabled, and the pNext chain includes an instance of VkRenderPassAttachmentBeginInfoKHR, its attachmentCount must be zero (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-pNext-03206)"},
     {"VUID-VkRenderPassBeginInfo-pNext-pNext", "Each pNext member of any structure (including this one) in the pNext chain must be either NULL or a pointer to a valid instance of VkDeviceGroupRenderPassBeginInfo, VkRenderPassAttachmentBeginInfoKHR, or VkRenderPassSampleLocationsBeginInfoEXT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-pNext-pNext)"},
     {"VUID-VkRenderPassBeginInfo-renderPass-00904", "renderPass must be compatible with the renderPass member of the VkFramebufferCreateInfo structure specified when creating framebuffer. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-renderPass-00904)"},
     {"VUID-VkRenderPassBeginInfo-renderPass-parameter", "renderPass must be a valid VkRenderPass handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassBeginInfo-renderPass-parameter)"},
@@ -2064,7 +2126,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkRenderPassCreateInfo-pAttachments-02511", "For any member of pAttachments with a stencilLoadOp equal to VK_ATTACHMENT_LOAD_OP_CLEAR, the first use of that attachment must not specify a layout equal to VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-02511)"},
     {"VUID-VkRenderPassCreateInfo-pAttachments-parameter", "If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pAttachments-parameter)"},
     {"VUID-VkRenderPassCreateInfo-pDependencies-00837", "For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-00837)"},
-    {"VUID-VkRenderPassCreateInfo-pDependencies-00838", "For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-00838)"},
+    {"VUID-VkRenderPassCreateInfo-pDependencies-00838", "For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-00838)"},
     {"VUID-VkRenderPassCreateInfo-pDependencies-parameter", "If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pDependencies-parameter)"},
     {"VUID-VkRenderPassCreateInfo-pNext-01926", "If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the subpass member of each element of its pAspectReferences member must be less than subpassCount (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01926)"},
     {"VUID-VkRenderPassCreateInfo-pNext-01927", "If the pNext chain includes an instance of VkRenderPassInputAttachmentAspectCreateInfo, the inputAttachmentIndex member of each element of its pAspectReferences member must be less than the value of inputAttachmentCount in the member of pSubpasses identified by its subpass member (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo-pNext-01927)"},
@@ -2093,8 +2155,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkRenderPassCreateInfo2KHR-pAttachments-parameter", "If attachmentCount is not 0, pAttachments must be a valid pointer to an array of attachmentCount valid VkAttachmentDescription2KHR structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pAttachments-parameter)"},
     {"VUID-VkRenderPassCreateInfo2KHR-pCorrelatedViewMasks-03056", "The set of bits included in any element of pCorrelatedViewMasks must not overlap with the set of bits included in any other element of pCorrelatedViewMasks (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pCorrelatedViewMasks-03056)"},
     {"VUID-VkRenderPassCreateInfo2KHR-pCorrelatedViewMasks-parameter", "If correlatedViewMaskCount is not 0, pCorrelatedViewMasks must be a valid pointer to an array of correlatedViewMaskCount uint32_t values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pCorrelatedViewMasks-parameter)"},
-    {"VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054", "For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054)"},
-    {"VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055", "For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055)"},
+    {"VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054", "For any element of pDependencies, if the srcSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the srcStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the source subpass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054)"},
+    {"VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055", "For any element of pDependencies, if the dstSubpass is not VK_SUBPASS_EXTERNAL, all stage flags included in the dstStageMask member of that dependency must be a pipeline stage supported by the pipeline identified by the pipelineBindPoint member of the destination subpass (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055)"},
     {"VUID-VkRenderPassCreateInfo2KHR-pDependencies-03060", "For any element of pDependencies where its srcSubpass member equals its dstSubpass member, if the viewMask member of the corresponding element of pSubpasses includes more than one bit, its dependencyFlags member must include VK_DEPENDENCY_VIEW_LOCAL_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pDependencies-03060)"},
     {"VUID-VkRenderPassCreateInfo2KHR-pDependencies-parameter", "If dependencyCount is not 0, pDependencies must be a valid pointer to an array of dependencyCount valid VkSubpassDependency2KHR structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pDependencies-parameter)"},
     {"VUID-VkRenderPassCreateInfo2KHR-pNext-pNext", "pNext must be NULL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkRenderPassCreateInfo2KHR-pNext-pNext)"},
@@ -2219,7 +2281,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter", "semaphore must be a valid VkSemaphore handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSemaphoreGetWin32HandleInfoKHR-semaphore-parameter)"},
     {"VUID-VkShaderModuleCreateInfo-codeSize-01085", "codeSize must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01085)"},
     {"VUID-VkShaderModuleCreateInfo-codeSize-01086", "codeSize must be a multiple of 4 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-codeSize-01086)"},
-    {"VUID-VkShaderModuleCreateInfo-flags-zerobitmask", "flags must be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-flags-zerobitmask)"},
+    {"VUID-VkShaderModuleCreateInfo-flags-parameter", "flags must be a valid combination of VkShaderModuleCreateFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-flags-parameter)"},
     {"VUID-VkShaderModuleCreateInfo-pCode-01087", "pCode must point to valid SPIR-V code, formatted and packed as described by the Khronos SPIR-V Specification (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01087)"},
     {"VUID-VkShaderModuleCreateInfo-pCode-01088", "pCode must adhere to the validation rules described by the Validation Rules within a Module section of the SPIR-V Environment appendix (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01088)"},
     {"VUID-VkShaderModuleCreateInfo-pCode-01089", "pCode must declare the Shader capability for SPIR-V code (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkShaderModuleCreateInfo-pCode-01089)"},
@@ -2321,7 +2383,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkSubpassDependency-dstStageMask-02102", "If the task shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-02102)"},
     {"VUID-VkSubpassDependency-dstStageMask-parameter", "dstStageMask must be a valid combination of VkPipelineStageFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-parameter)"},
     {"VUID-VkSubpassDependency-dstStageMask-requiredbitmask", "dstStageMask must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-dstStageMask-requiredbitmask)"},
-    {"VUID-VkSubpassDependency-dstSubpass-00859", "If dstSubpass is not VK_SUBPASS_EXTERNAL, dstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-dstSubpass-00859)"},
     {"VUID-VkSubpassDependency-srcAccessMask-00868", "Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcAccessMask-00868)"},
     {"VUID-VkSubpassDependency-srcAccessMask-parameter", "srcAccessMask must be a valid combination of VkAccessFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcAccessMask-parameter)"},
     {"VUID-VkSubpassDependency-srcStageMask-00860", "If the geometry shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-00860)"},
@@ -2330,12 +2391,10 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkSubpassDependency-srcStageMask-02100", "If the task shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-02100)"},
     {"VUID-VkSubpassDependency-srcStageMask-parameter", "srcStageMask must be a valid combination of VkPipelineStageFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-parameter)"},
     {"VUID-VkSubpassDependency-srcStageMask-requiredbitmask", "srcStageMask must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcStageMask-requiredbitmask)"},
-    {"VUID-VkSubpassDependency-srcSubpass-00858", "If srcSubpass is not VK_SUBPASS_EXTERNAL, srcStageMask must not include VK_PIPELINE_STAGE_HOST_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00858)"},
     {"VUID-VkSubpassDependency-srcSubpass-00864", "srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00864)"},
     {"VUID-VkSubpassDependency-srcSubpass-00865", "srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00865)"},
     {"VUID-VkSubpassDependency-srcSubpass-00867", "If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00867)"},
     {"VUID-VkSubpassDependency-srcSubpass-00872", "If srcSubpass equals dstSubpass and that subpass has more than one bit set in the view mask, then dependencyFlags must include VK_DEPENDENCY_VIEW_LOCAL_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-00872)"},
-    {"VUID-VkSubpassDependency-srcSubpass-01989", "If srcSubpass is equal to dstSubpass, srcStageMask and dstStageMask must not set any bits that are neither VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, nor one of the graphics pipeline stages (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-01989)"},
     {"VUID-VkSubpassDependency-srcSubpass-02243", "If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency-srcSubpass-02243)"},
     {"VUID-VkSubpassDependency2KHR-dependencyFlags-03090", "If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, srcSubpass must not be equal to VK_SUBPASS_EXTERNAL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-dependencyFlags-03090)"},
     {"VUID-VkSubpassDependency2KHR-dependencyFlags-03091", "If dependencyFlags includes VK_DEPENDENCY_VIEW_LOCAL_BIT, dstSubpass must not be equal to VK_SUBPASS_EXTERNAL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-dependencyFlags-03091)"},
@@ -2349,7 +2408,6 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkSubpassDependency2KHR-dstStageMask-03083", "If the tessellation shaders feature is not enabled, dstStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-dstStageMask-03083)"},
     {"VUID-VkSubpassDependency2KHR-dstStageMask-parameter", "dstStageMask must be a valid combination of VkPipelineStageFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-dstStageMask-parameter)"},
     {"VUID-VkSubpassDependency2KHR-dstStageMask-requiredbitmask", "dstStageMask must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-dstStageMask-requiredbitmask)"},
-    {"VUID-VkSubpassDependency2KHR-dstSubpass-03079", "If dstSubpass is not VK_SUBPASS_EXTERNAL, dstStageMask must not include VK_PIPELINE_STAGE_HOST_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-dstSubpass-03079)"},
     {"VUID-VkSubpassDependency2KHR-sType-sType", "sType must be VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-sType-sType)"},
     {"VUID-VkSubpassDependency2KHR-srcAccessMask-03088", "Any access flag included in srcAccessMask must be supported by one of the pipeline stages in srcStageMask, as specified in the table of supported access types (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcAccessMask-03088)"},
     {"VUID-VkSubpassDependency2KHR-srcAccessMask-parameter", "srcAccessMask must be a valid combination of VkAccessFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcAccessMask-parameter)"},
@@ -2359,9 +2417,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkSubpassDependency2KHR-srcStageMask-03082", "If the tessellation shaders feature is not enabled, srcStageMask must not contain VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT or VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcStageMask-03082)"},
     {"VUID-VkSubpassDependency2KHR-srcStageMask-parameter", "srcStageMask must be a valid combination of VkPipelineStageFlagBits values (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcStageMask-parameter)"},
     {"VUID-VkSubpassDependency2KHR-srcStageMask-requiredbitmask", "srcStageMask must not be 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcStageMask-requiredbitmask)"},
-    {"VUID-VkSubpassDependency2KHR-srcSubpass-02244", "If srcSubpass is equal to dstSubpass, srcStageMask and dstStageMask must not set any bits that are neither VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, nor one of the graphics pipeline stages (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcSubpass-02244)"},
     {"VUID-VkSubpassDependency2KHR-srcSubpass-02245", "If srcSubpass equals dstSubpass, and srcStageMask and dstStageMask both include a framebuffer-space stage, then dependencyFlags must include VK_DEPENDENCY_BY_REGION_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcSubpass-02245)"},
-    {"VUID-VkSubpassDependency2KHR-srcSubpass-03078", "If srcSubpass is not VK_SUBPASS_EXTERNAL, srcStageMask must not include VK_PIPELINE_STAGE_HOST_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcSubpass-03078)"},
     {"VUID-VkSubpassDependency2KHR-srcSubpass-03084", "srcSubpass must be less than or equal to dstSubpass, unless one of them is VK_SUBPASS_EXTERNAL, to avoid cyclic dependencies and ensure a valid execution order (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcSubpass-03084)"},
     {"VUID-VkSubpassDependency2KHR-srcSubpass-03085", "srcSubpass and dstSubpass must not both be equal to VK_SUBPASS_EXTERNAL (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcSubpass-03085)"},
     {"VUID-VkSubpassDependency2KHR-srcSubpass-03087", "If srcSubpass is equal to dstSubpass and not all of the stages in srcStageMask and dstStageMask are framebuffer-space stages, the logically latest pipeline stage in srcStageMask must be logically earlier than or equal to the logically earliest pipeline stage in dstStageMask (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkSubpassDependency2KHR-srcSubpass-03087)"},
@@ -2601,6 +2657,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkWriteDescriptorSet-descriptorType-02221", "If descriptorType is VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, the pNext chain must include a VkWriteDescriptorSetInlineUniformBlockEXT structure whose dataSize member equals descriptorCount (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-02221)"},
     {"VUID-VkWriteDescriptorSet-descriptorType-02382", "If descriptorType is VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, the pNext chain must include a VkWriteDescriptorSetAccelerationStructureNV structure whose accelerationStructureCount member equals descriptorCount (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-02382)"},
     {"VUID-VkWriteDescriptorSet-descriptorType-02738", "If descriptorType is VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, and if any element of pImageInfo has a imageView member that was created with a VkSamplerYcbcrConversionInfo structure in its pNext chain, then dstSet must have been allocated with a layout that included immutable samplers for dstBinding, and the corresponding immutable sampler must have been created with an identically defined VkSamplerYcbcrConversionInfo object (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-02738)"},
+    {"VUID-VkWriteDescriptorSet-descriptorType-02752", "If descriptorType is VK_DESCRIPTOR_TYPE_SAMPLER, then dstSet must not have been allocated with a layout that included immutable samplers for dstBinding (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-02752)"},
     {"VUID-VkWriteDescriptorSet-descriptorType-parameter", "descriptorType must be a valid VkDescriptorType value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-descriptorType-parameter)"},
     {"VUID-VkWriteDescriptorSet-dstArrayElement-00321", "The sum of dstArrayElement and descriptorCount must be less than or equal to the number of array elements in the descriptor set binding specified by dstBinding, and all applicable consecutive bindings, as described by consecutive binding updates (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-dstArrayElement-00321)"},
     {"VUID-VkWriteDescriptorSet-dstBinding-00315", "dstBinding must be less than or equal to the maximum value of binding of all VkDescriptorSetLayoutBinding structures specified when dstSet's descriptor set layout was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-dstBinding-00315)"},
@@ -2611,6 +2668,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-VkWriteDescriptorSet-sType-unique", "Each sType member in the pNext chain must be unique (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSet-sType-unique)"},
     {"VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-02236", "accelerationStructureCount must be equal to descriptorCount in the extended structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-02236)"},
     {"VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-arraylength", "accelerationStructureCount must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSetAccelerationStructureNV-accelerationStructureCount-arraylength)"},
+    {"VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-02764", "Each acceleration structure in pAccelerationStructures must have been created with VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-02764)"},
     {"VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-parameter", "pAccelerationStructures must be a valid pointer to an array of accelerationStructureCount valid VkAccelerationStructureNV handles (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSetAccelerationStructureNV-pAccelerationStructures-parameter)"},
     {"VUID-VkWriteDescriptorSetAccelerationStructureNV-sType-sType", "sType must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSetAccelerationStructureNV-sType-sType)"},
     {"VUID-VkWriteDescriptorSetInlineUniformBlockEXT-dataSize-02222", "dataSize must be an integer multiple of 4 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-VkWriteDescriptorSetInlineUniformBlockEXT-dataSize-02222)"},
@@ -2659,11 +2717,14 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter", "physicalDevice must be a valid VkPhysicalDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAcquireXlibDisplayEXT-physicalDevice-parameter)"},
     {"VUID-vkAllocateCommandBuffers-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateCommandBuffers-device-parameter)"},
     {"VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter", "pAllocateInfo must be a valid pointer to a valid VkCommandBufferAllocateInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateCommandBuffers-pAllocateInfo-parameter)"},
+    {"VUID-vkAllocateCommandBuffers-pAllocateInfo::commandBufferCount-arraylength", "The value referenced by pAllocateInfo::commandBufferCount must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateCommandBuffers-pAllocateInfo::commandBufferCount-arraylength)"},
     {"VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter", "pCommandBuffers must be a valid pointer to an array of pAllocateInfo::commandBufferCount VkCommandBuffer handles (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateCommandBuffers-pCommandBuffers-parameter)"},
     {"VUID-vkAllocateDescriptorSets-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateDescriptorSets-device-parameter)"},
     {"VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter", "pAllocateInfo must be a valid pointer to a valid VkDescriptorSetAllocateInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateDescriptorSets-pAllocateInfo-parameter)"},
+    {"VUID-vkAllocateDescriptorSets-pAllocateInfo::descriptorSetCount-arraylength", "The value referenced by pAllocateInfo::descriptorSetCount must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateDescriptorSets-pAllocateInfo::descriptorSetCount-arraylength)"},
     {"VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter", "pDescriptorSets must be a valid pointer to an array of pAllocateInfo::descriptorSetCount VkDescriptorSet handles (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateDescriptorSets-pDescriptorSets-parameter)"},
     {"VUID-vkAllocateMemory-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateMemory-device-parameter)"},
+    {"VUID-vkAllocateMemory-deviceCoherentMemory-02790", "If the deviceCoherentMemory feature is not enabled, pAllocateInfo->memoryTypeIndex must not identify a memory type supporting VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateMemory-deviceCoherentMemory-02790)"},
     {"VUID-vkAllocateMemory-pAllocateInfo-01713", "pAllocateInfo->allocationSize must be less than or equal to VkPhysicalDeviceMemoryProperties::memoryHeaps[pAllocateInfo->memoryTypeIndex].size as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-01713)"},
     {"VUID-vkAllocateMemory-pAllocateInfo-01714", "pAllocateInfo->memoryTypeIndex must be less than VkPhysicalDeviceMemoryProperties::memoryTypeCount as returned by vkGetPhysicalDeviceMemoryProperties for the VkPhysicalDevice that device was created from. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-01714)"},
     {"VUID-vkAllocateMemory-pAllocateInfo-parameter", "pAllocateInfo must be a valid pointer to a valid VkMemoryAllocateInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkAllocateMemory-pAllocateInfo-parameter)"},
@@ -2690,8 +2751,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkBindBufferMemory-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-device-parameter)"},
     {"VUID-vkBindBufferMemory-memory-01035", "memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetBufferMemoryRequirements with buffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-01035)"},
     {"VUID-vkBindBufferMemory-memory-01508", "If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::buffer was not VK_NULL_HANDLE, then buffer must equal VkMemoryDedicatedAllocateInfo::buffer, and memoryOffset must be zero. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-01508)"},
-    {"VUID-vkBindBufferMemory-memory-02726", "If memory was allocated with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-02726)"},
-    {"VUID-vkBindBufferMemory-memory-02727", "If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-02727)"},
+    {"VUID-vkBindBufferMemory-memory-02726", "If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-02726)"},
+    {"VUID-vkBindBufferMemory-memory-02727", "If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryBufferCreateInfo::handleTypes when buffer was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-02727)"},
     {"VUID-vkBindBufferMemory-memory-parameter", "memory must be a valid VkDeviceMemory handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-parameter)"},
     {"VUID-vkBindBufferMemory-memory-parent", "memory must have been created, allocated, or retrieved from device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memory-parent)"},
     {"VUID-vkBindBufferMemory-memoryOffset-01031", "memoryOffset must be less than the size of memory (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindBufferMemory-memoryOffset-01031)"},
@@ -2712,11 +2773,11 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkBindImageMemory-image-parameter", "image must be a valid VkImage handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-parameter)"},
     {"VUID-vkBindImageMemory-image-parent", "image must have been created, allocated, or retrieved from device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-image-parent)"},
     {"VUID-vkBindImageMemory-memory-01047", "memory must have been allocated using one of the memory types allowed in the memoryTypeBits member of the VkMemoryRequirements structure returned from a call to vkGetImageMemoryRequirements with image (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-01047)"},
-    {"VUID-vkBindImageMemory-memory-01509", "If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-01509)"},
+    {"VUID-vkBindImageMemory-memory-01509", "If the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-01509)"},
     {"VUID-vkBindImageMemory-memory-02628", "If the dedicated allocation image aliasing feature is not enabled, and the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then image must equal VkMemoryDedicatedAllocateInfo::image and memoryOffset must be zero. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-02628)"},
     {"VUID-vkBindImageMemory-memory-02629", "If the dedicated allocation image aliasing feature is enabled, and the VkMemoryAllocateInfo provided when memory was allocated included an instance of VkMemoryDedicatedAllocateInfo in its pNext chain, and VkMemoryDedicatedAllocateInfo::image was not VK_NULL_HANDLE, then memoryOffset must be zero, and image must be either equal to VkMemoryDedicatedAllocateInfo::image or an image that was created using the same parameters in VkImageCreateInfo, with the exception that extent and arrayLayers may differ subject to the following restrictions: every dimension in the extent parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created; and the arrayLayers parameter of the image being bound must be equal to or smaller than the original image for which the allocation was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-02629)"},
-    {"VUID-vkBindImageMemory-memory-02728", "If memory was allocated with VkExportMemoryAllocateInfo::handleTypes not equal to 0, at least one handle type it contained must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-02728)"},
-    {"VUID-vkBindImageMemory-memory-02729", "If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-02729)"},
+    {"VUID-vkBindImageMemory-memory-02728", "If the value of VkExportMemoryAllocateInfo::handleTypes used to allocate memory is not 0, it must include at least one of the handles set in VkExternalMemoryImageCreateInfo::handleTypes when image was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-02728)"},
+    {"VUID-vkBindImageMemory-memory-02729", "If memory was created by a memory import operation, the external handle type of the imported memory must also have been set in VkExternalMemoryImageCreateInfo::handleTypes when image was created (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-02729)"},
     {"VUID-vkBindImageMemory-memory-parameter", "memory must be a valid VkDeviceMemory handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-parameter)"},
     {"VUID-vkBindImageMemory-memory-parent", "memory must have been created, allocated, or retrieved from device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memory-parent)"},
     {"VUID-vkBindImageMemory-memoryOffset-01046", "memoryOffset must be less than the size of memory (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkBindImageMemory-memoryOffset-01046)"},
@@ -2791,6 +2852,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCmdBeginRenderPass2KHR-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass2KHR-commandBuffer-parameter)"},
     {"VUID-vkCmdBeginRenderPass2KHR-commandBuffer-recording", "commandBuffer must be in the recording state (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass2KHR-commandBuffer-recording)"},
     {"VUID-vkCmdBeginRenderPass2KHR-framebuffer-02533", "For any attachment in framebuffer that is used by renderPass and is bound to memory locations that are also bound to another attachment used by renderPass, and if at least one of those uses causes either attachment to be written to, both attachments must have had the VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT set (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass2KHR-framebuffer-02533)"},
+    {"VUID-vkCmdBeginRenderPass2KHR-framebuffer-02779", "Both the framebuffer and renderPass members of pRenderPassBegin must have been created on the same VkDevice that commandBuffer was allocated on (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass2KHR-framebuffer-02779)"},
     {"VUID-vkCmdBeginRenderPass2KHR-initialLayout-03094", "If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass2KHR-initialLayout-03094)"},
     {"VUID-vkCmdBeginRenderPass2KHR-initialLayout-03096", "If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, or VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass2KHR-initialLayout-03096)"},
     {"VUID-vkCmdBeginRenderPass2KHR-initialLayout-03097", "If any of the initialLayout or finalLayout member of the VkAttachmentDescription structures or the layout member of the VkAttachmentReference structures specified when creating the render pass specified in the renderPass member of pRenderPassBegin is VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL then the corresponding attachment image view of the framebuffer specified in the framebuffer member of pRenderPassBegin must have been created with a usage value including VK_IMAGE_USAGE_SAMPLED_BIT or VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBeginRenderPass2KHR-initialLayout-03097)"},
@@ -2840,6 +2902,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCmdBindIndexBuffer-commandBuffer-recording", "commandBuffer must be in the recording state (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commandBuffer-recording)"},
     {"VUID-vkCmdBindIndexBuffer-commonparent", "Both of buffer, and commandBuffer must have been created, allocated, or retrieved from the same VkDevice (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBindIndexBuffer-commonparent)"},
     {"VUID-vkCmdBindIndexBuffer-indexType-02507", "indexType must not be VK_INDEX_TYPE_NONE_NV. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBindIndexBuffer-indexType-02507)"},
+    {"VUID-vkCmdBindIndexBuffer-indexType-02765", "If indexType is VK_INDEX_TYPE_UINT8_EXT, the indexTypeUint8 feature must be enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBindIndexBuffer-indexType-02765)"},
     {"VUID-vkCmdBindIndexBuffer-indexType-parameter", "indexType must be a valid VkIndexType value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBindIndexBuffer-indexType-parameter)"},
     {"VUID-vkCmdBindIndexBuffer-offset-00431", "offset must be less than the size of buffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBindIndexBuffer-offset-00431)"},
     {"VUID-vkCmdBindIndexBuffer-offset-00432", "The sum of offset and the address of the range of VkDeviceMemory object that is backing buffer, must be a multiple of the type indicated by indexType (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBindIndexBuffer-offset-00432)"},
@@ -2957,6 +3020,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCmdBuildAccelerationStructureNV-geometryCount-02241", "geometryCount must be less than or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBuildAccelerationStructureNV-geometryCount-02241)"},
     {"VUID-vkCmdBuildAccelerationStructureNV-instanceData-parameter", "If instanceData is not VK_NULL_HANDLE, instanceData must be a valid VkBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBuildAccelerationStructureNV-instanceData-parameter)"},
     {"VUID-vkCmdBuildAccelerationStructureNV-pInfo-parameter", "pInfo must be a valid pointer to a valid VkAccelerationStructureInfoNV structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBuildAccelerationStructureNV-pInfo-parameter)"},
+    {"VUID-vkCmdBuildAccelerationStructureNV-renderpass", "This command must only be called outside of a render pass instance (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBuildAccelerationStructureNV-renderpass)"},
     {"VUID-vkCmdBuildAccelerationStructureNV-scratch-parameter", "scratch must be a valid VkBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBuildAccelerationStructureNV-scratch-parameter)"},
     {"VUID-vkCmdBuildAccelerationStructureNV-src-parameter", "If src is not VK_NULL_HANDLE, src must be a valid VkAccelerationStructureNV handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBuildAccelerationStructureNV-src-parameter)"},
     {"VUID-vkCmdBuildAccelerationStructureNV-update-02489", "If update is VK_TRUE, src must not be VK_NULL_HANDLE (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdBuildAccelerationStructureNV-update-02489)"},
@@ -3041,6 +3105,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCmdCopyAccelerationStructureNV-dst-parameter", "dst must be a valid VkAccelerationStructureNV handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdCopyAccelerationStructureNV-dst-parameter)"},
     {"VUID-vkCmdCopyAccelerationStructureNV-mode-02496", "mode must be VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV or VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdCopyAccelerationStructureNV-mode-02496)"},
     {"VUID-vkCmdCopyAccelerationStructureNV-mode-parameter", "mode must be a valid VkCopyAccelerationStructureModeNV value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdCopyAccelerationStructureNV-mode-parameter)"},
+    {"VUID-vkCmdCopyAccelerationStructureNV-renderpass", "This command must only be called outside of a render pass instance (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdCopyAccelerationStructureNV-renderpass)"},
     {"VUID-vkCmdCopyAccelerationStructureNV-src-02497", "src must have been built with VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV if mode is VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdCopyAccelerationStructureNV-src-02497)"},
     {"VUID-vkCmdCopyAccelerationStructureNV-src-parameter", "src must be a valid VkAccelerationStructureNV handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdCopyAccelerationStructureNV-src-parameter)"},
     {"VUID-vkCmdCopyBuffer-commandBuffer-01822", "If commandBuffer is an unprotected command buffer, then srcBuffer must not be a protected buffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdCopyBuffer-commandBuffer-01822)"},
@@ -4002,6 +4067,11 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCmdSetExclusiveScissorNV-offset-02039", "Evaluation of (offset.y + extent.height) for each member of pExclusiveScissors must not cause a signed integer addition overflow (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetExclusiveScissorNV-offset-02039)"},
     {"VUID-vkCmdSetExclusiveScissorNV-pExclusiveScissors-parameter", "pExclusiveScissors must be a valid pointer to an array of exclusiveScissorCount VkRect2D structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetExclusiveScissorNV-pExclusiveScissors-parameter)"},
     {"VUID-vkCmdSetExclusiveScissorNV-x-02037", "The x and y members of offset in each member of pExclusiveScissors must be greater than or equal to 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetExclusiveScissorNV-x-02037)"},
+    {"VUID-vkCmdSetLineStippleEXT-None-02775", "The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_LINE_STIPPLE_EXT dynamic state enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineStippleEXT-None-02775)"},
+    {"VUID-vkCmdSetLineStippleEXT-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics operations (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineStippleEXT-commandBuffer-cmdpool)"},
+    {"VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineStippleEXT-commandBuffer-parameter)"},
+    {"VUID-vkCmdSetLineStippleEXT-commandBuffer-recording", "commandBuffer must be in the recording state (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineStippleEXT-commandBuffer-recording)"},
+    {"VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776", "lineStippleFactor must be in the range [1,256] (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776)"},
     {"VUID-vkCmdSetLineWidth-None-00787", "The bound graphics pipeline must have been created with the VK_DYNAMIC_STATE_LINE_WIDTH dynamic state enabled (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineWidth-None-00787)"},
     {"VUID-vkCmdSetLineWidth-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support graphics operations (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-cmdpool)"},
     {"VUID-vkCmdSetLineWidth-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdSetLineWidth-commandBuffer-parameter)"},
@@ -4131,6 +4201,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02455", "raygenShaderBindingOffset must be less than the size of raygenShaderBindingTableBuffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02455)"},
     {"VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02456", "raygenShaderBindingOffset must be a multiple of VkPhysicalDeviceRayTracingPropertiesNV::shaderGroupBaseAlignment (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdTraceRaysNV-raygenShaderBindingOffset-02456)"},
     {"VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-parameter", "raygenShaderBindingTableBuffer must be a valid VkBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdTraceRaysNV-raygenShaderBindingTableBuffer-parameter)"},
+    {"VUID-vkCmdTraceRaysNV-renderpass", "This command must only be called outside of a render pass instance (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdTraceRaysNV-renderpass)"},
     {"VUID-vkCmdTraceRaysNV-width-02469", "width must be less than or equal to VkPhysicalDeviceLimits::maxComputeWorkGroupCount[0] (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdTraceRaysNV-width-02469)"},
     {"VUID-vkCmdUpdateBuffer-commandBuffer-01813", "If commandBuffer is an unprotected command buffer, then dstBuffer must not be a protected buffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-01813)"},
     {"VUID-vkCmdUpdateBuffer-commandBuffer-01814", "If commandBuffer is a protected command buffer, then dstBuffer must not be an unprotected buffer (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdUpdateBuffer-commandBuffer-01814)"},
@@ -4188,6 +4259,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-parameter", "queryPool must be a valid VkQueryPool handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryPool-parameter)"},
     {"VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-02242", "queryType must be VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-02242)"},
     {"VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-parameter", "queryType must be a valid VkQueryType value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdWriteAccelerationStructuresPropertiesNV-queryType-parameter)"},
+    {"VUID-vkCmdWriteAccelerationStructuresPropertiesNV-renderpass", "This command must only be called outside of a render pass instance (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdWriteAccelerationStructuresPropertiesNV-renderpass)"},
     {"VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool", "The VkCommandPool that commandBuffer was allocated from must support transfer, graphics, or compute operations (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-cmdpool)"},
     {"VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter", "commandBuffer must be a valid VkCommandBuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-parameter)"},
     {"VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording", "commandBuffer must be in the recording state (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCmdWriteBufferMarkerAMD-commandBuffer-recording)"},
@@ -4289,6 +4361,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkCreateFence-pFence-parameter", "pFence must be a valid pointer to a VkFence handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCreateFence-pFence-parameter)"},
     {"VUID-vkCreateFramebuffer-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCreateFramebuffer-device-parameter)"},
     {"VUID-vkCreateFramebuffer-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCreateFramebuffer-pAllocator-parameter)"},
+    {"VUID-vkCreateFramebuffer-pCreateInfo-02777", "If pCreateInfo->flags does not include VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR, and attachmentCount is not 0, each element of pCreateInfo->pAttachments must have been created on device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCreateFramebuffer-pCreateInfo-02777)"},
     {"VUID-vkCreateFramebuffer-pCreateInfo-parameter", "pCreateInfo must be a valid pointer to a valid VkFramebufferCreateInfo structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCreateFramebuffer-pCreateInfo-parameter)"},
     {"VUID-vkCreateFramebuffer-pFramebuffer-parameter", "pFramebuffer must be a valid pointer to a VkFramebuffer handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCreateFramebuffer-pFramebuffer-parameter)"},
     {"VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength", "createInfoCount must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkCreateGraphicsPipelines-createInfoCount-arraylength)"},
@@ -4686,6 +4759,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkFreeMemory-memory-parameter", "If memory is not VK_NULL_HANDLE, memory must be a valid VkDeviceMemory handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkFreeMemory-memory-parameter)"},
     {"VUID-vkFreeMemory-memory-parent", "If memory is a valid handle, it must have been created, allocated, or retrieved from device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkFreeMemory-memory-parent)"},
     {"VUID-vkFreeMemory-pAllocator-parameter", "If pAllocator is not NULL, pAllocator must be a valid pointer to a valid VkAllocationCallbacks structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkFreeMemory-pAllocator-parameter)"},
+    {"VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-02787", "accelerationStructure must be bound completely and contiguously to a single VkDeviceMemory object via vkBindAccelerationStructureMemoryNV (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-02787)"},
     {"VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parameter", "accelerationStructure must be a valid VkAccelerationStructureNV handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parameter)"},
     {"VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parent", "accelerationStructure must have been created, allocated, or retrieved from device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetAccelerationStructureHandleNV-accelerationStructure-parent)"},
     {"VUID-vkGetAccelerationStructureHandleNV-dataSize-02240", "dataSize must be large enough to contain the result of the query, as described above (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetAccelerationStructureHandleNV-dataSize-02240)"},
@@ -5013,6 +5087,26 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkGetPipelineCacheData-pDataSize-parameter", "pDataSize must be a valid pointer to a size_t value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineCacheData-pDataSize-parameter)"},
     {"VUID-vkGetPipelineCacheData-pipelineCache-parameter", "pipelineCache must be a valid VkPipelineCache handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineCacheData-pipelineCache-parameter)"},
     {"VUID-vkGetPipelineCacheData-pipelineCache-parent", "pipelineCache must have been created, allocated, or retrieved from device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineCacheData-pipelineCache-parent)"},
+    {"VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableInternalRepresentationsKHR-device-parameter)"},
+    {"VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pExecutableInfo-parameter", "pExecutableInfo must be a valid pointer to a valid VkPipelineExecutableInfoKHR structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pExecutableInfo-parameter)"},
+    {"VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentationCount-parameter", "pInternalRepresentationCount must be a valid pointer to a uint32_t value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentationCount-parameter)"},
+    {"VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentations-parameter", "If the value referenced by pInternalRepresentationCount is not 0, and pInternalRepresentations is not NULL, pInternalRepresentations must be a valid pointer to an array of pInternalRepresentationCount VkPipelineExecutableInternalRepresentationKHR structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pInternalRepresentations-parameter)"},
+    {"VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03277", "pipeline member of pExecutableInfo must have been created with device. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03277)"},
+    {"VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278", "pipeline member of pExecutableInfo must have been created with VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR set in the flags field of VkGraphicsPipelineCreateInfo or VkComputePipelineCreateInfo. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipeline-03278)"},
+    {"VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipelineExecutableProperties-03276", "pipelineExecutableProperties must be enabled. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableInternalRepresentationsKHR-pipelineExecutableProperties-03276)"},
+    {"VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutablePropertiesKHR-device-parameter)"},
+    {"VUID-vkGetPipelineExecutablePropertiesKHR-pExecutableCount-parameter", "pExecutableCount must be a valid pointer to a uint32_t value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutablePropertiesKHR-pExecutableCount-parameter)"},
+    {"VUID-vkGetPipelineExecutablePropertiesKHR-pPipelineInfo-parameter", "pPipelineInfo must be a valid pointer to a valid VkPipelineInfoKHR structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutablePropertiesKHR-pPipelineInfo-parameter)"},
+    {"VUID-vkGetPipelineExecutablePropertiesKHR-pProperties-parameter", "If the value referenced by pExecutableCount is not 0, and pProperties is not NULL, pProperties must be a valid pointer to an array of pExecutableCount VkPipelineExecutablePropertiesKHR structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutablePropertiesKHR-pProperties-parameter)"},
+    {"VUID-vkGetPipelineExecutablePropertiesKHR-pipeline-03271", "pipeline member of pPipelineInfo must have been created with device. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutablePropertiesKHR-pipeline-03271)"},
+    {"VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableProperties-03270", "pipelineExecutableProperties must be enabled. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutablePropertiesKHR-pipelineExecutableProperties-03270)"},
+    {"VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableStatisticsKHR-device-parameter)"},
+    {"VUID-vkGetPipelineExecutableStatisticsKHR-pExecutableInfo-parameter", "pExecutableInfo must be a valid pointer to a valid VkPipelineExecutableInfoKHR structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableStatisticsKHR-pExecutableInfo-parameter)"},
+    {"VUID-vkGetPipelineExecutableStatisticsKHR-pStatisticCount-parameter", "pStatisticCount must be a valid pointer to a uint32_t value (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableStatisticsKHR-pStatisticCount-parameter)"},
+    {"VUID-vkGetPipelineExecutableStatisticsKHR-pStatistics-parameter", "If the value referenced by pStatisticCount is not 0, and pStatistics is not NULL, pStatistics must be a valid pointer to an array of pStatisticCount VkPipelineExecutableStatisticKHR structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableStatisticsKHR-pStatistics-parameter)"},
+    {"VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03273", "pipeline member of pExecutableInfo must have been created with device. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03273)"},
+    {"VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274", "pipeline member of pExecutableInfo must have been created with VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR set in the flags field of VkGraphicsPipelineCreateInfo or VkComputePipelineCreateInfo. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableStatisticsKHR-pipeline-03274)"},
+    {"VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272", "pipelineExecutableInfo must be enabled. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetPipelineExecutableStatisticsKHR-pipelineExecutableInfo-03272)"},
     {"VUID-vkGetQueryPoolResults-dataSize-00817", "dataSize must be large enough to contain the result of each query, as described here (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetQueryPoolResults-dataSize-00817)"},
     {"VUID-vkGetQueryPoolResults-dataSize-arraylength", "dataSize must be greater than 0 (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetQueryPoolResults-dataSize-arraylength)"},
     {"VUID-vkGetQueryPoolResults-device-parameter", "device must be a valid VkDevice handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkGetQueryPoolResults-device-parameter)"},
@@ -5127,7 +5221,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkQueueBindSparse-fence-parameter", "If fence is not VK_NULL_HANDLE, fence must be a valid VkFence handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-fence-parameter)"},
     {"VUID-vkQueueBindSparse-pBindInfo-parameter", "If bindInfoCount is not 0, pBindInfo must be a valid pointer to an array of bindInfoCount valid VkBindSparseInfo structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-pBindInfo-parameter)"},
     {"VUID-vkQueueBindSparse-pSignalSemaphores-01115", "Each element of the pSignalSemaphores member of each element of pBindInfo must be unsignaled when the semaphore signal operation it defines is executed on the device (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-pSignalSemaphores-01115)"},
-    {"VUID-vkQueueBindSparse-pWaitSemaphores-01116", "When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, no other queue must be waiting on the same semaphore. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-pWaitSemaphores-01116)"},
+    {"VUID-vkQueueBindSparse-pWaitSemaphores-01116", "When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pBindInfo executes on queue, there must be no other queues waiting on the same semaphore. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-pWaitSemaphores-01116)"},
     {"VUID-vkQueueBindSparse-pWaitSemaphores-01117", "All elements of the pWaitSemaphores member of all elements of pBindInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-pWaitSemaphores-01117)"},
     {"VUID-vkQueueBindSparse-queue-parameter", "queue must be a valid VkQueue handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-queue-parameter)"},
     {"VUID-vkQueueBindSparse-queuetype", "The queue must support sparse binding operations (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueBindSparse-queuetype)"},
@@ -5138,7 +5232,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkQueuePresentKHR-pPresentInfo-parameter", "pPresentInfo must be a valid pointer to a valid VkPresentInfoKHR structure (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pPresentInfo-parameter)"},
     {"VUID-vkQueuePresentKHR-pSwapchains-01292", "Each element of pSwapchains member of pPresentInfo must be a swapchain that is created for a surface for which presentation is supported from queue as determined using a call to vkGetPhysicalDeviceSurfaceSupportKHR (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pSwapchains-01292)"},
     {"VUID-vkQueuePresentKHR-pSwapchains-01293", "If more than one member of pSwapchains was created from a display surface, all display surfaces referenced that refer to the same display must use the same display mode (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pSwapchains-01293)"},
-    {"VUID-vkQueuePresentKHR-pWaitSemaphores-01294", "When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, no other queue must be waiting on the same semaphore. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pWaitSemaphores-01294)"},
+    {"VUID-vkQueuePresentKHR-pWaitSemaphores-01294", "When a semaphore unsignal operation defined by the elements of the pWaitSemaphores member of pPresentInfo executes on queue, there must be no other queues waiting on the same semaphore. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pWaitSemaphores-01294)"},
     {"VUID-vkQueuePresentKHR-pWaitSemaphores-01295", "All elements of the pWaitSemaphores member of pPresentInfo must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-pWaitSemaphores-01295)"},
     {"VUID-vkQueuePresentKHR-queue-parameter", "queue must be a valid VkQueue handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueuePresentKHR-queue-parameter)"},
     {"VUID-vkQueueSetPerformanceConfigurationINTEL-commonparent", "Both of configuration, and queue must have been created, allocated, or retrieved from the same VkDevice (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSetPerformanceConfigurationINTEL-commonparent)"},
@@ -5158,7 +5252,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     {"VUID-vkQueueSubmit-pSubmits-02207", "If any element of pSubmits->pCommandBuffers includes a Queue Family Transfer Acquire Operation, there must exist a previously submitted Queue Family Transfer Release Operation on a queue in the queue family identified by the acquire operation, with parameters matching the acquire operation as defined in the definition of such acquire operations, and which happens before the acquire operation. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSubmit-pSubmits-02207)"},
     {"VUID-vkQueueSubmit-pSubmits-parameter", "If submitCount is not 0, pSubmits must be a valid pointer to an array of submitCount valid VkSubmitInfo structures (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSubmit-pSubmits-parameter)"},
     {"VUID-vkQueueSubmit-pWaitDstStageMask-00066", "Any stage flag included in any element of the pWaitDstStageMask member of any element of pSubmits must be a pipeline stage supported by one of the capabilities of queue, as specified in the table of supported pipeline stages. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSubmit-pWaitDstStageMask-00066)"},
-    {"VUID-vkQueueSubmit-pWaitSemaphores-00068", "When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, no other queue must be waiting on the same semaphore. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSubmit-pWaitSemaphores-00068)"},
+    {"VUID-vkQueueSubmit-pWaitSemaphores-00068", "When a semaphore unsignal operation defined by any element of the pWaitSemaphores member of any element of pSubmits executes on queue, there must be no other queues waiting on the same semaphore. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSubmit-pWaitSemaphores-00068)"},
     {"VUID-vkQueueSubmit-pWaitSemaphores-00069", "All elements of the pWaitSemaphores member of all elements of pSubmits must be semaphores that are signaled, or have semaphore signal operations previously submitted for execution. (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSubmit-pWaitSemaphores-00069)"},
     {"VUID-vkQueueSubmit-queue-parameter", "queue must be a valid VkQueue handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueSubmit-queue-parameter)"},
     {"VUID-vkQueueWaitIdle-queue-parameter", "queue must be a valid VkQueue handle (https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VUID-vkQueueWaitIdle-queue-parameter)"},
@@ -5350,26 +5444,27 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     prefix##SETDISCARDRECTANGLEEXT = 68,\
     prefix##SETEVENT = 69,\
     prefix##SETEXCLUSIVESCISSORNV = 70,\
-    prefix##SETLINEWIDTH = 71,\
-    prefix##SETPERFORMANCEMARKERINTEL = 72,\
-    prefix##SETPERFORMANCEOVERRIDEINTEL = 73,\
-    prefix##SETPERFORMANCESTREAMMARKERINTEL = 74,\
-    prefix##SETSAMPLELOCATIONSEXT = 75,\
-    prefix##SETSCISSOR = 76,\
-    prefix##SETSTENCILCOMPAREMASK = 77,\
-    prefix##SETSTENCILREFERENCE = 78,\
-    prefix##SETSTENCILWRITEMASK = 79,\
-    prefix##SETVIEWPORT = 80,\
-    prefix##SETVIEWPORTSHADINGRATEPALETTENV = 81,\
-    prefix##SETVIEWPORTWSCALINGNV = 82,\
-    prefix##TRACERAYSNV = 83,\
-    prefix##UPDATEBUFFER = 84,\
-    prefix##WAITEVENTS = 85,\
-    prefix##WRITEACCELERATIONSTRUCTURESPROPERTIESNV = 86,\
-    prefix##WRITEBUFFERMARKERAMD = 87,\
-    prefix##WRITETIMESTAMP = 88,\
-    prefix##ENDCOMMANDBUFFER = 89,\
-    prefix##RANGE_SIZE = 90
+    prefix##SETLINESTIPPLEEXT = 71,\
+    prefix##SETLINEWIDTH = 72,\
+    prefix##SETPERFORMANCEMARKERINTEL = 73,\
+    prefix##SETPERFORMANCEOVERRIDEINTEL = 74,\
+    prefix##SETPERFORMANCESTREAMMARKERINTEL = 75,\
+    prefix##SETSAMPLELOCATIONSEXT = 76,\
+    prefix##SETSCISSOR = 77,\
+    prefix##SETSTENCILCOMPAREMASK = 78,\
+    prefix##SETSTENCILREFERENCE = 79,\
+    prefix##SETSTENCILWRITEMASK = 80,\
+    prefix##SETVIEWPORT = 81,\
+    prefix##SETVIEWPORTSHADINGRATEPALETTENV = 82,\
+    prefix##SETVIEWPORTWSCALINGNV = 83,\
+    prefix##TRACERAYSNV = 84,\
+    prefix##UPDATEBUFFER = 85,\
+    prefix##WAITEVENTS = 86,\
+    prefix##WRITEACCELERATIONSTRUCTURESPROPERTIESNV = 87,\
+    prefix##WRITEBUFFERMARKERAMD = 88,\
+    prefix##WRITETIMESTAMP = 89,\
+    prefix##ENDCOMMANDBUFFER = 90,\
+    prefix##RANGE_SIZE = 91
 
 #define VUID_CMD_NAME_LIST\
     "Command_Undefined",\
@@ -5443,6 +5538,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     "vkCmdSetDiscardRectangleEXT",\
     "vkCmdSetEvent",\
     "vkCmdSetExclusiveScissorNV",\
+    "vkCmdSetLineStippleEXT",\
     "vkCmdSetLineWidth",\
     "vkCmdSetPerformanceMarkerINTEL",\
     "vkCmdSetPerformanceOverrideINTEL",\
@@ -5535,6 +5631,7 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
     "VUID-vkCmdSetDiscardRectangleEXT-commandBuffer-recording",\
     "VUID-vkCmdSetEvent-commandBuffer-recording",\
     "VUID-vkCmdSetExclusiveScissorNV-commandBuffer-recording",\
+    "VUID-vkCmdSetLineStippleEXT-commandBuffer-recording",\
     "VUID-vkCmdSetLineWidth-commandBuffer-recording",\
     "VUID-vkCmdSetPerformanceMarkerINTEL-commandBuffer-recording",\
     "VUID-vkCmdSetPerformanceOverrideINTEL-commandBuffer-recording",\
diff --git a/layers/gpu_validation.cpp b/layers/gpu_validation.cpp
index effb01137..38737a956 100644
--- a/layers/gpu_validation.cpp
+++ b/layers/gpu_validation.cpp
@@ -38,6 +38,10 @@
 // This is the number of bindings in the debug descriptor set.
 static const uint32_t kNumBindingsInSet = 2;
 
+static const VkShaderStageFlags kShaderStageAllRayTracing =
+    VK_SHADER_STAGE_ANY_HIT_BIT_NV | VK_SHADER_STAGE_CALLABLE_BIT_NV | VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV |
+    VK_SHADER_STAGE_INTERSECTION_BIT_NV | VK_SHADER_STAGE_MISS_BIT_NV | VK_SHADER_STAGE_RAYGEN_BIT_NV;
+
 // Implementation for Descriptor Set Manager class
 GpuDescriptorSetManager::GpuDescriptorSetManager(CoreChecks *dev_data) { dev_data_ = dev_data; }
 
@@ -191,7 +195,8 @@ VkResult CoreChecks::GpuInitializeVma() {
     VmaAllocatorCreateInfo allocatorInfo = {};
     allocatorInfo.device = device;
     ValidationObject *device_object = GetLayerDataPtr(get_dispatch_key(allocatorInfo.device), layer_data_map);
-    ValidationObject *validation_data = GetValidationObject(device_object->object_dispatch, LayerObjectTypeCoreValidation);
+    ValidationObject *validation_data =
+        ValidationObject::GetValidationObject(device_object->object_dispatch, LayerObjectTypeCoreValidation);
     CoreChecks *core_checks = static_cast<CoreChecks *>(validation_data);
     allocatorInfo.physicalDevice = core_checks->physical_device;
 
@@ -225,17 +230,29 @@ void CoreChecks::ReportSetupProblem(VkDebugReportObjectTypeEXT object_type, uint
 }
 
 // Turn on necessary device features.
-void CoreChecks::GpuPreCallRecordCreateDevice(VkPhysicalDevice gpu, std::unique_ptr<safe_VkDeviceCreateInfo> &create_info,
+void CoreChecks::GpuPreCallRecordCreateDevice(VkPhysicalDevice gpu, safe_VkDeviceCreateInfo *modified_create_info,
                                               VkPhysicalDeviceFeatures *supported_features) {
     if (supported_features->fragmentStoresAndAtomics || supported_features->vertexPipelineStoresAndAtomics) {
-        VkPhysicalDeviceFeatures new_features = {};
-        if (create_info->pEnabledFeatures) {
-            new_features = *create_info->pEnabledFeatures;
+        VkPhysicalDeviceFeatures *features = nullptr;
+        if (modified_create_info->pEnabledFeatures) {
+            // If pEnabledFeatures, VkPhysicalDeviceFeatures2 in pNext chain is not allowed
+            features = const_cast<VkPhysicalDeviceFeatures *>(modified_create_info->pEnabledFeatures);
+        } else {
+            VkPhysicalDeviceFeatures2 *features2 = nullptr;
+            features2 =
+                const_cast<VkPhysicalDeviceFeatures2 *>(lvl_find_in_chain<VkPhysicalDeviceFeatures2>(modified_create_info->pNext));
+            if (features2) features = &features2->features;
+        }
+        if (features) {
+            features->fragmentStoresAndAtomics = supported_features->fragmentStoresAndAtomics;
+            features->vertexPipelineStoresAndAtomics = supported_features->vertexPipelineStoresAndAtomics;
+        } else {
+            VkPhysicalDeviceFeatures new_features = {};
+            new_features.fragmentStoresAndAtomics = supported_features->fragmentStoresAndAtomics;
+            new_features.vertexPipelineStoresAndAtomics = supported_features->vertexPipelineStoresAndAtomics;
+            delete modified_create_info->pEnabledFeatures;
+            modified_create_info->pEnabledFeatures = new VkPhysicalDeviceFeatures(new_features);
         }
-        new_features.fragmentStoresAndAtomics = supported_features->fragmentStoresAndAtomics;
-        new_features.vertexPipelineStoresAndAtomics = supported_features->vertexPipelineStoresAndAtomics;
-        delete create_info->pEnabledFeatures;
-        create_info->pEnabledFeatures = new VkPhysicalDeviceFeatures(new_features);
     }
 }
 
@@ -289,14 +306,14 @@ void CoreChecks::GpuPostCallRecordCreateDevice(const CHECK_ENABLED *enables, con
             0,  // output
             VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             1,
-            VK_SHADER_STAGE_ALL_GRAPHICS | VK_SHADER_STAGE_COMPUTE_BIT,
+            VK_SHADER_STAGE_ALL_GRAPHICS | VK_SHADER_STAGE_COMPUTE_BIT | kShaderStageAllRayTracing,
             NULL,
         },
         {
             1,  // input
             VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
             1,
-            VK_SHADER_STAGE_ALL_GRAPHICS | VK_SHADER_STAGE_COMPUTE_BIT,
+            VK_SHADER_STAGE_ALL_GRAPHICS | VK_SHADER_STAGE_COMPUTE_BIT | kShaderStageAllRayTracing,
             NULL,
         },
     };
@@ -332,15 +349,17 @@ void CoreChecks::GpuPostCallRecordCreateDevice(const CHECK_ENABLED *enables, con
 
 // Clean up device-related resources
 void CoreChecks::GpuPreCallRecordDestroyDevice() {
-    if (gpu_validation_state->barrier_command_buffer) {
-        DispatchFreeCommandBuffers(device, gpu_validation_state->barrier_command_pool, 1,
-                                   &gpu_validation_state->barrier_command_buffer);
-        gpu_validation_state->barrier_command_buffer = VK_NULL_HANDLE;
-    }
-    if (gpu_validation_state->barrier_command_pool) {
-        DispatchDestroyCommandPool(device, gpu_validation_state->barrier_command_pool, NULL);
-        gpu_validation_state->barrier_command_pool = VK_NULL_HANDLE;
+    for (auto &queue_barrier_command_info_kv : gpu_validation_state->queue_barrier_command_infos) {
+        GpuQueueBarrierCommandInfo &queue_barrier_command_info = queue_barrier_command_info_kv.second;
+
+        DispatchFreeCommandBuffers(device, queue_barrier_command_info.barrier_command_pool, 1,
+                                   &queue_barrier_command_info.barrier_command_buffer);
+        queue_barrier_command_info.barrier_command_buffer = VK_NULL_HANDLE;
+
+        DispatchDestroyCommandPool(device, queue_barrier_command_info.barrier_command_pool, NULL);
+        queue_barrier_command_info.barrier_command_pool = VK_NULL_HANDLE;
     }
+    gpu_validation_state->queue_barrier_command_infos.clear();
     if (gpu_validation_state->debug_desc_layout) {
         DispatchDestroyDescriptorSetLayout(device, gpu_validation_state->debug_desc_layout, NULL);
         gpu_validation_state->debug_desc_layout = VK_NULL_HANDLE;
@@ -434,44 +453,89 @@ std::vector<safe_VkGraphicsPipelineCreateInfo> CoreChecks::GpuPreCallRecordCreat
     VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo *pCreateInfos,
     const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, std::vector<std::unique_ptr<PIPELINE_STATE>> &pipe_state) {
     std::vector<safe_VkGraphicsPipelineCreateInfo> new_pipeline_create_infos;
-
-    GpuPreCallRecordPipelineCreations(count, pCreateInfos, nullptr, pAllocator, pPipelines, pipe_state, &new_pipeline_create_infos,
-                                      nullptr, VK_PIPELINE_BIND_POINT_GRAPHICS);
+    GpuPreCallRecordPipelineCreations(count, pCreateInfos, pAllocator, pPipelines, pipe_state, &new_pipeline_create_infos,
+                                      VK_PIPELINE_BIND_POINT_GRAPHICS);
     return new_pipeline_create_infos;
 }
 std::vector<safe_VkComputePipelineCreateInfo> CoreChecks::GpuPreCallRecordCreateComputePipelines(
     VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo *pCreateInfos,
     const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, std::vector<std::unique_ptr<PIPELINE_STATE>> &pipe_state) {
     std::vector<safe_VkComputePipelineCreateInfo> new_pipeline_create_infos;
-    GpuPreCallRecordPipelineCreations(count, nullptr, pCreateInfos, pAllocator, pPipelines, pipe_state, nullptr,
-                                      &new_pipeline_create_infos, VK_PIPELINE_BIND_POINT_COMPUTE);
+    GpuPreCallRecordPipelineCreations(count, pCreateInfos, pAllocator, pPipelines, pipe_state, &new_pipeline_create_infos,
+                                      VK_PIPELINE_BIND_POINT_COMPUTE);
     return new_pipeline_create_infos;
 }
+std::vector<safe_VkRayTracingPipelineCreateInfoNV> CoreChecks::GpuPreCallRecordCreateRayTracingPipelinesNV(
+    VkPipelineCache pipelineCache, uint32_t count, const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
+    const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines, std::vector<std::unique_ptr<PIPELINE_STATE>> &pipe_state) {
+    std::vector<safe_VkRayTracingPipelineCreateInfoNV> new_pipeline_create_infos;
+    GpuPreCallRecordPipelineCreations(count, pCreateInfos, pAllocator, pPipelines, pipe_state, &new_pipeline_create_infos,
+                                      VK_PIPELINE_BIND_POINT_RAY_TRACING_NV);
+    return new_pipeline_create_infos;
+}
+template <typename CreateInfo>
+struct CreatePipelineTraits {};
+template <>
+struct CreatePipelineTraits<VkGraphicsPipelineCreateInfo> {
+    using SafeType = safe_VkGraphicsPipelineCreateInfo;
+    static const SafeType &GetPipelineCI(const PIPELINE_STATE *pipeline_state) { return pipeline_state->graphicsPipelineCI; }
+    static uint32_t GetStageCount(const VkGraphicsPipelineCreateInfo &createInfo) { return createInfo.stageCount; }
+    static VkShaderModule GetShaderModule(const VkGraphicsPipelineCreateInfo &createInfo, uint32_t stage) {
+        return createInfo.pStages[stage].module;
+    }
+    static void SetShaderModule(SafeType *createInfo, VkShaderModule shader_module, uint32_t stage) {
+        createInfo->pStages[stage].module = shader_module;
+    }
+};
+
+template <>
+struct CreatePipelineTraits<VkComputePipelineCreateInfo> {
+    using SafeType = safe_VkComputePipelineCreateInfo;
+    static const SafeType &GetPipelineCI(const PIPELINE_STATE *pipeline_state) { return pipeline_state->computePipelineCI; }
+    static uint32_t GetStageCount(const VkComputePipelineCreateInfo &createInfo) { return 1; }
+    static VkShaderModule GetShaderModule(const VkComputePipelineCreateInfo &createInfo, uint32_t stage) {
+        return createInfo.stage.module;
+    }
+    static void SetShaderModule(SafeType *createInfo, VkShaderModule shader_module, uint32_t stage) {
+        assert(stage == 0);
+        createInfo->stage.module = shader_module;
+    }
+};
+template <>
+struct CreatePipelineTraits<VkRayTracingPipelineCreateInfoNV> {
+    using SafeType = safe_VkRayTracingPipelineCreateInfoNV;
+    static const SafeType &GetPipelineCI(const PIPELINE_STATE *pipeline_state) { return pipeline_state->raytracingPipelineCI; }
+    static uint32_t GetStageCount(const VkRayTracingPipelineCreateInfoNV &createInfo) { return createInfo.stageCount; }
+    static VkShaderModule GetShaderModule(const VkRayTracingPipelineCreateInfoNV &createInfo, uint32_t stage) {
+        return createInfo.pStages[stage].module;
+    }
+    static void SetShaderModule(SafeType *createInfo, VkShaderModule shader_module, uint32_t stage) {
+        createInfo->pStages[stage].module = shader_module;
+    }
+};
 
 // Examine the pipelines to see if they use the debug descriptor set binding index.
 // If any do, create new non-instrumented shader modules and use them to replace the instrumented
 // shaders in the pipeline.  Return the (possibly) modified create infos to the caller.
-void CoreChecks::GpuPreCallRecordPipelineCreations(
-    uint32_t count, const VkGraphicsPipelineCreateInfo *pGraphicsCreateInfos,
-    const VkComputePipelineCreateInfo *pComputeCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines,
-    std::vector<std::unique_ptr<PIPELINE_STATE>> &pipe_state,
-    std::vector<safe_VkGraphicsPipelineCreateInfo> *new_graphics_pipeline_create_infos,
-    std::vector<safe_VkComputePipelineCreateInfo> *new_compute_pipeline_create_infos, const VkPipelineBindPoint bind_point) {
-    if (bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS && bind_point != VK_PIPELINE_BIND_POINT_COMPUTE) {
+template <typename CreateInfo, typename SafeCreateInfo>
+void CoreChecks::GpuPreCallRecordPipelineCreations(uint32_t count, const CreateInfo *pCreateInfos,
+                                                   const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines,
+                                                   std::vector<std::unique_ptr<PIPELINE_STATE>> &pipe_state,
+                                                   std::vector<SafeCreateInfo> *new_pipeline_create_infos,
+                                                   const VkPipelineBindPoint bind_point) {
+    using Accessor = CreatePipelineTraits<CreateInfo>;
+    if (bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS && bind_point != VK_PIPELINE_BIND_POINT_COMPUTE &&
+        bind_point != VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
         return;
     }
-    bool graphics_pipeline = (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS);
 
     // Walk through all the pipelines, make a copy of each and flag each pipeline that contains a shader that uses the debug
     // descriptor set index.
     for (uint32_t pipeline = 0; pipeline < count; ++pipeline) {
-        auto stageCount = graphics_pipeline ? pGraphicsCreateInfos[pipeline].stageCount : 1;
-        bool replace_shaders = false;
-        if (graphics_pipeline)
-            new_graphics_pipeline_create_infos->push_back(pipe_state[pipeline]->graphicsPipelineCI);
-        else
-            new_compute_pipeline_create_infos->push_back(pipe_state[pipeline]->computePipelineCI);
+        uint32_t stageCount = Accessor::GetStageCount(pCreateInfos[pipeline]);
+        new_pipeline_create_infos->push_back(Accessor::GetPipelineCI(pipe_state[pipeline].get()));
 
+        bool replace_shaders = false;
         if (pipe_state[pipeline]->active_slots.find(gpu_validation_state->desc_set_bind_index) !=
             pipe_state[pipeline]->active_slots.end()) {
             replace_shaders = true;
@@ -484,11 +548,8 @@ void CoreChecks::GpuPreCallRecordPipelineCreations(
 
         if (replace_shaders) {
             for (uint32_t stage = 0; stage < stageCount; ++stage) {
-                const SHADER_MODULE_STATE *shader;
-                if (graphics_pipeline)
-                    shader = GetShaderModuleState(pGraphicsCreateInfos[pipeline].pStages[stage].module);
-                else
-                    shader = GetShaderModuleState(pComputeCreateInfos[pipeline].stage.module);
+                const SHADER_MODULE_STATE *shader = GetShaderModuleState(Accessor::GetShaderModule(pCreateInfos[pipeline], stage));
+
                 VkShaderModuleCreateInfo create_info = {};
                 VkShaderModule shader_module;
                 create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
@@ -496,14 +557,10 @@ void CoreChecks::GpuPreCallRecordPipelineCreations(
                 create_info.codeSize = shader->words.size() * sizeof(uint32_t);
                 VkResult result = DispatchCreateShaderModule(device, &create_info, pAllocator, &shader_module);
                 if (result == VK_SUCCESS) {
-                    if (graphics_pipeline)
-                        new_graphics_pipeline_create_infos[pipeline].data()->pStages[stage].module = shader_module;
-                    else
-                        new_compute_pipeline_create_infos[pipeline].data()->stage.module = shader_module;
+                    Accessor::SetShaderModule(new_pipeline_create_infos[pipeline].data(), shader_module, stage);
                 } else {
-                    ReportSetupProblem(VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT,
-                                       (graphics_pipeline) ? HandleToUint64(pGraphicsCreateInfos[pipeline].pStages[stage].module)
-                                                           : HandleToUint64(pComputeCreateInfos[pipeline].stage.module),
+                    uint64_t moduleHandle = HandleToUint64(Accessor::GetShaderModule(pCreateInfos[pipeline], stage));
+                    ReportSetupProblem(VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT, moduleHandle,
                                        "Unable to replace instrumented shader with non-instrumented one.  "
                                        "Device could become unstable.");
                 }
@@ -514,37 +571,66 @@ void CoreChecks::GpuPreCallRecordPipelineCreations(
 
 void CoreChecks::GpuPostCallRecordCreateGraphicsPipelines(const uint32_t count, const VkGraphicsPipelineCreateInfo *pCreateInfos,
                                                           const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
-    GpuPostCallRecordPipelineCreations(count, pCreateInfos, nullptr, pAllocator, pPipelines, VK_PIPELINE_BIND_POINT_GRAPHICS);
+    GpuPostCallRecordPipelineCreations(count, pCreateInfos, pAllocator, pPipelines, VK_PIPELINE_BIND_POINT_GRAPHICS);
 }
 void CoreChecks::GpuPostCallRecordCreateComputePipelines(const uint32_t count, const VkComputePipelineCreateInfo *pCreateInfos,
                                                          const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
-    GpuPostCallRecordPipelineCreations(count, nullptr, pCreateInfos, pAllocator, pPipelines, VK_PIPELINE_BIND_POINT_GRAPHICS);
+    GpuPostCallRecordPipelineCreations(count, pCreateInfos, pAllocator, pPipelines, VK_PIPELINE_BIND_POINT_COMPUTE);
+}
+void CoreChecks::GpuPostCallRecordCreateRayTracingPipelinesNV(const uint32_t count,
+                                                              const VkRayTracingPipelineCreateInfoNV *pCreateInfos,
+                                                              const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) {
+    GpuPostCallRecordPipelineCreations(count, pCreateInfos, pAllocator, pPipelines, VK_PIPELINE_BIND_POINT_RAY_TRACING_NV);
 }
+
 // For every pipeline:
 // - For every shader in a pipeline:
 //   - If the shader had to be replaced in PreCallRecord (because the pipeline is using the debug desc set index):
 //     - Destroy it since it has been bound into the pipeline by now.  This is our only chance to delete it.
 //   - Track the shader in the shader_map
 //   - Save the shader binary if it contains debug code
-void CoreChecks::GpuPostCallRecordPipelineCreations(const uint32_t count, const VkGraphicsPipelineCreateInfo *pGraphicsCreateInfos,
-                                                    const VkComputePipelineCreateInfo *pComputeCreateInfos,
+template <typename CreateInfo>
+void CoreChecks::GpuPostCallRecordPipelineCreations(const uint32_t count, const CreateInfo *pCreateInfos,
                                                     const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines,
                                                     const VkPipelineBindPoint bind_point) {
-    if (bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS && bind_point != VK_PIPELINE_BIND_POINT_COMPUTE) {
+    using Accessor = CreatePipelineTraits<CreateInfo>;
+    if (bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS && bind_point != VK_PIPELINE_BIND_POINT_COMPUTE &&
+        bind_point != VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
         return;
     }
     for (uint32_t pipeline = 0; pipeline < count; ++pipeline) {
-        auto pipeline_state = GetPipelineState(pPipelines[pipeline]);
+        auto pipeline_state = ValidationStateTracker::GetPipelineState(pPipelines[pipeline]);
         if (nullptr == pipeline_state) continue;
-        for (uint32_t stage = 0; stage < pipeline_state->graphicsPipelineCI.stageCount; ++stage) {
+
+        uint32_t stageCount = 0;
+        if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+            stageCount = pipeline_state->graphicsPipelineCI.stageCount;
+        } else if (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) {
+            stageCount = 1;
+        } else if (bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
+            stageCount = pipeline_state->raytracingPipelineCI.stageCount;
+        } else {
+            assert(false);
+        }
+
+        for (uint32_t stage = 0; stage < stageCount; ++stage) {
             if (pipeline_state->active_slots.find(gpu_validation_state->desc_set_bind_index) !=
                 pipeline_state->active_slots.end()) {
-                if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS)
-                    DispatchDestroyShaderModule(device, pGraphicsCreateInfos->pStages[stage].module, pAllocator);
-                else
-                    DispatchDestroyShaderModule(device, pComputeCreateInfos->stage.module, pAllocator);
+                DispatchDestroyShaderModule(device, Accessor::GetShaderModule(pCreateInfos[pipeline], stage), pAllocator);
+            }
+
+            const SHADER_MODULE_STATE *shader_state = nullptr;
+            if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+                shader_state = GetShaderModuleState(pipeline_state->graphicsPipelineCI.pStages[stage].module);
+            } else if (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) {
+                assert(stage == 0);
+                shader_state = GetShaderModuleState(pipeline_state->computePipelineCI.stage.module);
+            } else if (bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
+                shader_state = GetShaderModuleState(pipeline_state->raytracingPipelineCI.pStages[stage].module);
+            } else {
+                assert(false);
             }
-            auto shader_state = GetShaderModuleState(pipeline_state->graphicsPipelineCI.pStages[stage].module);
+
             std::vector<unsigned int> code;
             // Save the shader binary if debug info is present.
             // The core_validation ShaderModule tracker saves the binary too, but discards it when the ShaderModule
@@ -561,8 +647,18 @@ void CoreChecks::GpuPostCallRecordPipelineCreations(const uint32_t count, const
             gpu_validation_state->shader_map[shader_state->gpu_validation_shader_id].pipeline = pipeline_state->pipeline;
             // Be careful to use the originally bound (instrumented) shader here, even if PreCallRecord had to back it
             // out with a non-instrumented shader.  The non-instrumented shader (found in pCreateInfo) was destroyed above.
-            gpu_validation_state->shader_map[shader_state->gpu_validation_shader_id].shader_module =
-                pipeline_state->graphicsPipelineCI.pStages[stage].module;
+            VkShaderModule shader_module = VK_NULL_HANDLE;
+            if (bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+                shader_module = pipeline_state->graphicsPipelineCI.pStages[stage].module;
+            } else if (bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) {
+                assert(stage == 0);
+                shader_module = pipeline_state->computePipelineCI.stage.module;
+            } else if (bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
+                shader_module = pipeline_state->raytracingPipelineCI.pStages[stage].module;
+            } else {
+                assert(false);
+            }
+            gpu_validation_state->shader_map[shader_state->gpu_validation_shader_id].shader_module = shader_module;
             gpu_validation_state->shader_map[shader_state->gpu_validation_shader_id].pgm = std::move(code);
         }
     }
@@ -629,28 +725,52 @@ static void GenerateStageMessage(const uint32_t *debug_record, std::string &msg)
     using namespace spvtools;
     std::ostringstream strm;
     switch (debug_record[kInstCommonOutStageIdx]) {
-        case 0: {
+        case spv::ExecutionModelVertex: {
             strm << "Stage = Vertex. Vertex Index = " << debug_record[kInstVertOutVertexIndex]
                  << " Instance Index = " << debug_record[kInstVertOutInstanceIndex] << ". ";
         } break;
-        case 1: {
+        case spv::ExecutionModelTessellationControl: {
             strm << "Stage = Tessellation Control.  Invocation ID = " << debug_record[kInstTessOutInvocationId] << ". ";
         } break;
-        case 2: {
+        case spv::ExecutionModelTessellationEvaluation: {
             strm << "Stage = Tessellation Eval.  Invocation ID = " << debug_record[kInstTessOutInvocationId] << ". ";
         } break;
-        case 3: {
+        case spv::ExecutionModelGeometry: {
             strm << "Stage = Geometry.  Primitive ID = " << debug_record[kInstGeomOutPrimitiveId]
                  << " Invocation ID = " << debug_record[kInstGeomOutInvocationId] << ". ";
         } break;
-        case 4: {
+        case spv::ExecutionModelFragment: {
             strm << "Stage = Fragment.  Fragment coord (x,y) = ("
                  << *reinterpret_cast<const float *>(&debug_record[kInstFragOutFragCoordX]) << ", "
                  << *reinterpret_cast<const float *>(&debug_record[kInstFragOutFragCoordY]) << "). ";
         } break;
-        case 5: {
+        case spv::ExecutionModelGLCompute: {
             strm << "Stage = Compute.  Global invocation ID = " << debug_record[kInstCompOutGlobalInvocationId] << ". ";
         } break;
+        case spv::ExecutionModelRayGenerationNV: {
+            strm << "Stage = Ray Generation.  Global Launch ID (x,y,z) = (" << debug_record[kInstRayTracingOutLaunchIdX] << ", "
+                 << debug_record[kInstRayTracingOutLaunchIdY] << ", " << debug_record[kInstRayTracingOutLaunchIdZ] << "). ";
+        } break;
+        case spv::ExecutionModelIntersectionNV: {
+            strm << "Stage = Intersection.  Global Launch ID (x,y,z) = (" << debug_record[kInstRayTracingOutLaunchIdX] << ", "
+                 << debug_record[kInstRayTracingOutLaunchIdY] << ", " << debug_record[kInstRayTracingOutLaunchIdZ] << "). ";
+        } break;
+        case spv::ExecutionModelAnyHitNV: {
+            strm << "Stage = Any Hit.  Global Launch ID (x,y,z) = (" << debug_record[kInstRayTracingOutLaunchIdX] << ", "
+                 << debug_record[kInstRayTracingOutLaunchIdY] << ", " << debug_record[kInstRayTracingOutLaunchIdZ] << "). ";
+        } break;
+        case spv::ExecutionModelClosestHitNV: {
+            strm << "Stage = Closest Hit.  Global Launch ID (x,y,z) = (" << debug_record[kInstRayTracingOutLaunchIdX] << ", "
+                 << debug_record[kInstRayTracingOutLaunchIdY] << ", " << debug_record[kInstRayTracingOutLaunchIdZ] << "). ";
+        } break;
+        case spv::ExecutionModelMissNV: {
+            strm << "Stage = Miss.  Global Launch ID (x,y,z) = (" << debug_record[kInstRayTracingOutLaunchIdX] << ", "
+                 << debug_record[kInstRayTracingOutLaunchIdY] << ", " << debug_record[kInstRayTracingOutLaunchIdZ] << "). ";
+        } break;
+        case spv::ExecutionModelCallableNV: {
+            strm << "Stage = Callable.  Global Launch ID (x,y,z) = (" << debug_record[kInstRayTracingOutLaunchIdX] << ", "
+                 << debug_record[kInstRayTracingOutLaunchIdY] << ", " << debug_record[kInstRayTracingOutLaunchIdZ] << "). ";
+        } break;
         default: {
             strm << "Internal Error (unexpected stage = " << debug_record[kInstCommonOutStageIdx] << "). ";
             assert(false);
@@ -693,7 +813,8 @@ static std::string LookupDebugUtilsName(const debug_report_data *report_data, co
 // Generate message from the common portion of the debug report record.
 static void GenerateCommonMessage(const debug_report_data *report_data, const CMD_BUFFER_STATE *cb_node,
                                   const uint32_t *debug_record, const VkShaderModule shader_module_handle,
-                                  const VkPipeline pipeline_handle, const uint32_t draw_index, std::string &msg) {
+                                  const VkPipeline pipeline_handle, const VkPipelineBindPoint pipeline_bind_point,
+                                  const uint32_t operation_index, std::string &msg) {
     using namespace spvtools;
     std::ostringstream strm;
     if (shader_module_handle == VK_NULL_HANDLE) {
@@ -704,8 +825,18 @@ static void GenerateCommonMessage(const debug_report_data *report_data, const CM
     } else {
         strm << std::hex << std::showbase << "Command buffer "
              << LookupDebugUtilsName(report_data, HandleToUint64(cb_node->commandBuffer)) << "("
-             << HandleToUint64(cb_node->commandBuffer) << "). "
-             << "Draw Index " << draw_index << ". "
+             << HandleToUint64(cb_node->commandBuffer) << "). ";
+        if (pipeline_bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+            strm << "Draw ";
+        } else if (pipeline_bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) {
+            strm << "Compute ";
+        } else if (pipeline_bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
+            strm << "Ray Trace ";
+        } else {
+            assert(false);
+            strm << "Unknown Pipeline Operation ";
+        }
+        strm << "Index " << operation_index << ". "
              << "Pipeline " << LookupDebugUtilsName(report_data, HandleToUint64(pipeline_handle)) << "("
              << HandleToUint64(pipeline_handle) << "). "
              << "Shader Module " << LookupDebugUtilsName(report_data, HandleToUint64(shader_module_handle)) << "("
@@ -932,8 +1063,8 @@ static void GenerateSourceMessages(const std::vector<unsigned int> &pgm, const u
 // sure it is available when the pipeline is submitted.  (The ShaderModule tracking object also
 // keeps a copy, but it can be destroyed after the pipeline is created and before it is submitted.)
 //
-void CoreChecks::AnalyzeAndReportError(CMD_BUFFER_STATE *cb_node, VkQueue queue, uint32_t draw_index,
-                                       uint32_t *const debug_output_buffer) {
+void CoreChecks::AnalyzeAndReportError(CMD_BUFFER_STATE *cb_node, VkQueue queue, VkPipelineBindPoint pipeline_bind_point,
+                                       uint32_t operation_index, uint32_t *const debug_output_buffer) {
     using namespace spvtools;
     const uint32_t total_words = debug_output_buffer[0];
     // A zero here means that the shader instrumentation didn't write anything.
@@ -971,7 +1102,8 @@ void CoreChecks::AnalyzeAndReportError(CMD_BUFFER_STATE *cb_node, VkQueue queue,
     }
     GenerateValidationMessage(debug_record, validation_message, vuid_msg);
     GenerateStageMessage(debug_record, stage_message);
-    GenerateCommonMessage(report_data, cb_node, debug_record, shader_module_handle, pipeline_handle, draw_index, common_message);
+    GenerateCommonMessage(report_data, cb_node, debug_record, shader_module_handle, pipeline_handle, pipeline_bind_point,
+                          operation_index, common_message);
     GenerateSourceMessages(pgm, debug_record, filename_message, source_message);
     log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(queue),
             vuid_msg.c_str(), "%s %s %s %s%s", validation_message.c_str(), common_message.c_str(), stage_message.c_str(),
@@ -985,19 +1117,41 @@ void CoreChecks::AnalyzeAndReportError(CMD_BUFFER_STATE *cb_node, VkQueue queue,
 // For the given command buffer, map its debug data buffers and read their contents for analysis.
 void CoreChecks::ProcessInstrumentationBuffer(VkQueue queue, CMD_BUFFER_STATE *cb_node) {
     auto gpu_buffer_list = gpu_validation_state->GetGpuBufferInfo(cb_node->commandBuffer);
-    if (cb_node && cb_node->hasDrawCmd && gpu_buffer_list.size() > 0) {
+    if (cb_node && (cb_node->hasDrawCmd || cb_node->hasTraceRaysCmd || cb_node->hasDispatchCmd) && gpu_buffer_list.size() > 0) {
         VkResult result;
         char *pData;
         uint32_t draw_index = 0;
+        uint32_t compute_index = 0;
+        uint32_t ray_trace_index = 0;
 
         for (auto &buffer_info : gpu_buffer_list) {
             result = vmaMapMemory(gpu_validation_state->vmaAllocator, buffer_info.output_mem_block.allocation, (void **)&pData);
             // Analyze debug output buffer
             if (result == VK_SUCCESS) {
-                AnalyzeAndReportError(cb_node, queue, draw_index, (uint32_t *)pData);
+                uint32_t operation_index = 0;
+                if (buffer_info.pipeline_bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+                    operation_index = draw_index;
+                } else if (buffer_info.pipeline_bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) {
+                    operation_index = compute_index;
+                } else if (buffer_info.pipeline_bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
+                    operation_index = ray_trace_index;
+                } else {
+                    assert(false);
+                }
+
+                AnalyzeAndReportError(cb_node, queue, buffer_info.pipeline_bind_point, operation_index, (uint32_t *)pData);
                 vmaUnmapMemory(gpu_validation_state->vmaAllocator, buffer_info.output_mem_block.allocation);
             }
-            draw_index++;
+
+            if (buffer_info.pipeline_bind_point == VK_PIPELINE_BIND_POINT_GRAPHICS) {
+                draw_index++;
+            } else if (buffer_info.pipeline_bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) {
+                compute_index++;
+            } else if (buffer_info.pipeline_bind_point == VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
+                ray_trace_index++;
+            } else {
+                assert(false);
+            }
         }
     }
 }
@@ -1023,74 +1177,71 @@ void CoreChecks::UpdateInstrumentationBuffer(CMD_BUFFER_STATE *cb_node) {
 // Submit a memory barrier on graphics queues.
 // Lazy-create and record the needed command buffer.
 void CoreChecks::SubmitBarrier(VkQueue queue) {
-    uint32_t queue_family_index = 0;
+    auto queue_barrier_command_info_it =
+        gpu_validation_state->queue_barrier_command_infos.emplace(queue, GpuQueueBarrierCommandInfo{});
+    if (queue_barrier_command_info_it.second) {
+        GpuQueueBarrierCommandInfo &quere_barrier_command_info = queue_barrier_command_info_it.first->second;
 
-    auto it = queueMap.find(queue);
-    if (it != queueMap.end()) {
-        queue_family_index = it->second.queueFamilyIndex;
-    }
+        uint32_t queue_family_index = 0;
 
-    // Pay attention only to queues that support graphics.
-    // This ensures that the command buffer pool is created so that it can be used on a graphics queue.
-    VkQueueFlags queue_flags = GetPhysicalDeviceState()->queue_family_properties[queue_family_index].queueFlags;
-    if (!(queue_flags & VK_QUEUE_GRAPHICS_BIT)) {
-        return;
-    }
+        auto queue_state_it = queueMap.find(queue);
+        if (queue_state_it != queueMap.end()) {
+            queue_family_index = queue_state_it->second.queueFamilyIndex;
+        }
+
+        VkResult result = VK_SUCCESS;
 
-    // Lazy-allocate and record the command buffer.
-    if (gpu_validation_state->barrier_command_buffer == VK_NULL_HANDLE) {
-        VkResult result;
         VkCommandPoolCreateInfo pool_create_info = {};
         pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
         pool_create_info.queueFamilyIndex = queue_family_index;
-        result = DispatchCreateCommandPool(device, &pool_create_info, nullptr, &gpu_validation_state->barrier_command_pool);
+        result = DispatchCreateCommandPool(device, &pool_create_info, nullptr, &quere_barrier_command_info.barrier_command_pool);
         if (result != VK_SUCCESS) {
             ReportSetupProblem(VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
                                "Unable to create command pool for barrier CB.");
-            gpu_validation_state->barrier_command_pool = VK_NULL_HANDLE;
+            quere_barrier_command_info.barrier_command_pool = VK_NULL_HANDLE;
             return;
         }
 
-        VkCommandBufferAllocateInfo command_buffer_alloc_info = {};
-        command_buffer_alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
-        command_buffer_alloc_info.commandPool = gpu_validation_state->barrier_command_pool;
-        command_buffer_alloc_info.commandBufferCount = 1;
-        command_buffer_alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
-        result = DispatchAllocateCommandBuffers(device, &command_buffer_alloc_info, &gpu_validation_state->barrier_command_buffer);
+        VkCommandBufferAllocateInfo buffer_alloc_info = {};
+        buffer_alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+        buffer_alloc_info.commandPool = quere_barrier_command_info.barrier_command_pool;
+        buffer_alloc_info.commandBufferCount = 1;
+        buffer_alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
+        result = DispatchAllocateCommandBuffers(device, &buffer_alloc_info, &quere_barrier_command_info.barrier_command_buffer);
         if (result != VK_SUCCESS) {
             ReportSetupProblem(VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device),
                                "Unable to create barrier command buffer.");
-            DispatchDestroyCommandPool(device, gpu_validation_state->barrier_command_pool, nullptr);
-            gpu_validation_state->barrier_command_pool = VK_NULL_HANDLE;
-            gpu_validation_state->barrier_command_buffer = VK_NULL_HANDLE;
+            DispatchDestroyCommandPool(device, quere_barrier_command_info.barrier_command_pool, nullptr);
+            quere_barrier_command_info.barrier_command_pool = VK_NULL_HANDLE;
+            quere_barrier_command_info.barrier_command_buffer = VK_NULL_HANDLE;
             return;
         }
 
         // Hook up command buffer dispatch
-        gpu_validation_state->vkSetDeviceLoaderData(device, gpu_validation_state->barrier_command_buffer);
+        gpu_validation_state->vkSetDeviceLoaderData(device, quere_barrier_command_info.barrier_command_buffer);
 
         // Record a global memory barrier to force availability of device memory operations to the host domain.
         VkCommandBufferBeginInfo command_buffer_begin_info = {};
         command_buffer_begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
-        result = DispatchBeginCommandBuffer(gpu_validation_state->barrier_command_buffer, &command_buffer_begin_info);
-
+        result = DispatchBeginCommandBuffer(quere_barrier_command_info.barrier_command_buffer, &command_buffer_begin_info);
         if (result == VK_SUCCESS) {
             VkMemoryBarrier memory_barrier = {};
             memory_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
             memory_barrier.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
             memory_barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
 
-            DispatchCmdPipelineBarrier(gpu_validation_state->barrier_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            DispatchCmdPipelineBarrier(quere_barrier_command_info.barrier_command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                                        VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &memory_barrier, 0, nullptr, 0, nullptr);
-            DispatchEndCommandBuffer(gpu_validation_state->barrier_command_buffer);
+            DispatchEndCommandBuffer(quere_barrier_command_info.barrier_command_buffer);
         }
     }
 
-    if (gpu_validation_state->barrier_command_buffer) {
+    GpuQueueBarrierCommandInfo &quere_barrier_command_info = queue_barrier_command_info_it.first->second;
+    if (quere_barrier_command_info.barrier_command_buffer != VK_NULL_HANDLE) {
         VkSubmitInfo submit_info = {};
         submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
         submit_info.commandBufferCount = 1;
-        submit_info.pCommandBuffers = &gpu_validation_state->barrier_command_buffer;
+        submit_info.pCommandBuffers = &quere_barrier_command_info.barrier_command_buffer;
         DispatchQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
     }
 }
@@ -1131,8 +1282,8 @@ void CoreChecks::GpuPostCallQueueSubmit(VkQueue queue, uint32_t submitCount, con
 }
 
 void CoreChecks::GpuAllocateValidationResources(const VkCommandBuffer cmd_buffer, const VkPipelineBindPoint bind_point) {
-    // Does GPUAV support VK_PIPELINE_BIND_POINT_RAY_TRACING_NV?
-    if (bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS && bind_point != VK_PIPELINE_BIND_POINT_COMPUTE) {
+    if (bind_point != VK_PIPELINE_BIND_POINT_GRAPHICS && bind_point != VK_PIPELINE_BIND_POINT_COMPUTE &&
+        bind_point != VK_PIPELINE_BIND_POINT_RAY_TRACING_NV) {
         return;
     }
     VkResult result;
@@ -1190,19 +1341,28 @@ void CoreChecks::GpuAllocateValidationResources(const VkCommandBuffer cmd_buffer
     VkWriteDescriptorSet desc_writes[2] = {};
     uint32_t desc_count = 1;
     auto const &state = cb_node->lastBound[bind_point];
-    uint32_t number_of_sets = (uint32_t)state.boundDescriptorSets.size();
+    uint32_t number_of_sets = (uint32_t)state.per_set.size();
 
     // Figure out how much memory we need for the input block based on how many sets and bindings there are
     // and how big each of the bindings is
     if (number_of_sets > 0 && device_extensions.vk_ext_descriptor_indexing) {
         uint32_t descriptor_count = 0;  // Number of descriptors, including all array elements
         uint32_t binding_count = 0;     // Number of bindings based on the max binding number used
-        for (auto desc : state.boundDescriptorSets) {
+        for (auto s : state.per_set) {
+            auto desc = s.bound_descriptor_set;
             auto bindings = desc->GetLayout()->GetSortedBindingSet();
             if (bindings.size() > 0) {
                 binding_count += desc->GetLayout()->GetMaxBinding() + 1;
                 for (auto binding : bindings) {
-                    if (binding == desc->GetLayout()->GetMaxBinding() && desc->IsVariableDescriptorCount(binding)) {
+                    // Shader instrumentation is tracking inline uniform blocks as scalers. Don't try to validate inline uniform
+                    // blocks
+                    if (VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT == desc->GetLayout()->GetTypeFromBinding(binding)) {
+                        descriptor_count++;
+                        log_msg(report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
+                                VK_NULL_HANDLE, "UNASSIGNED-GPU-Assisted Validation Warning",
+                                "VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT descriptors will not be validated by GPU assisted "
+                                "validation");
+                    } else if (binding == desc->GetLayout()->GetMaxBinding() && desc->IsVariableDescriptorCount(binding)) {
                         descriptor_count += desc->GetVariableDescriptorCount();
                     } else {
                         descriptor_count += desc->GetDescriptorCountFromBinding(binding);
@@ -1247,7 +1407,8 @@ void CoreChecks::GpuAllocateValidationResources(const VkCommandBuffer cmd_buffer
         // Index of the start of the sets_to_bindings array
         pData[0] = number_of_sets + binding_count + 1;
 
-        for (auto desc : state.boundDescriptorSets) {
+        for (auto s : state.per_set) {
+            auto desc = s.bound_descriptor_set;
             auto layout = desc->GetLayout();
             auto bindings = layout->GetSortedBindingSet();
             if (bindings.size() > 0) {
@@ -1257,7 +1418,11 @@ void CoreChecks::GpuAllocateValidationResources(const VkCommandBuffer cmd_buffer
                 *sets_to_bindings++ = bindCounter + number_of_sets + binding_count;
                 for (auto binding : bindings) {
                     // For each binding, fill in its size in the sizes array
-                    if (binding == layout->GetMaxBinding() && desc->IsVariableDescriptorCount(binding)) {
+                    // Shader instrumentation is tracking inline uniform blocks as scalers. Don't try to validate inline uniform
+                    // blocks
+                    if (VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT == desc->GetLayout()->GetTypeFromBinding(binding)) {
+                        sizes[binding] = 1;
+                    } else if (binding == layout->GetMaxBinding() && desc->IsVariableDescriptorCount(binding)) {
                         sizes[binding] = desc->GetVariableDescriptorCount();
                     } else {
                         sizes[binding] = desc->GetDescriptorCountFromBinding(binding);
@@ -1265,6 +1430,13 @@ void CoreChecks::GpuAllocateValidationResources(const VkCommandBuffer cmd_buffer
                     // Fill in the starting index for this binding in the written array in the bindings_to_written array
                     bindings_to_written[binding] = written_index;
 
+                    // Shader instrumentation is tracking inline uniform blocks as scalers. Don't try to validate inline uniform
+                    // blocks
+                    if (VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT == desc->GetLayout()->GetTypeFromBinding(binding)) {
+                        pData[written_index++] = 1;
+                        continue;
+                    }
+
                     auto index_range = desc->GetGlobalIndexRangeFromBinding(binding, true);
                     // For each array element in the binding, update the written array with whether it has been written
                     for (uint32_t i = index_range.start; i < index_range.end; ++i) {
@@ -1319,11 +1491,12 @@ void CoreChecks::GpuAllocateValidationResources(const VkCommandBuffer cmd_buffer
     if (iter != cb_node->lastBound.end()) {
         auto pipeline_state = iter->second.pipeline_state;
         if (pipeline_state && (pipeline_state->pipeline_layout.set_layouts.size() <= gpu_validation_state->desc_set_bind_index)) {
-            DispatchCmdBindDescriptorSets(cmd_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline_state->pipeline_layout.layout,
+            DispatchCmdBindDescriptorSets(cmd_buffer, bind_point, pipeline_state->pipeline_layout.layout,
                                           gpu_validation_state->desc_set_bind_index, 1, desc_sets.data(), 0, nullptr);
         }
         // Record buffer and memory info in CB state tracking
-        gpu_validation_state->GetGpuBufferInfo(cmd_buffer).emplace_back(output_block, input_block, desc_sets[0], desc_pool);
+        gpu_validation_state->GetGpuBufferInfo(cmd_buffer)
+            .emplace_back(output_block, input_block, desc_sets[0], desc_pool, bind_point);
     } else {
         ReportSetupProblem(VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, HandleToUint64(device), "Unable to find pipeline state");
         vmaDestroyBuffer(gpu_validation_state->vmaAllocator, input_block.buffer, input_block.allocation);
diff --git a/layers/gpu_validation.h b/layers/gpu_validation.h
index cd2ed17a4..d3dd1ab41 100644
--- a/layers/gpu_validation.h
+++ b/layers/gpu_validation.h
@@ -33,9 +33,19 @@ struct GpuBufferInfo {
     GpuDeviceMemoryBlock input_mem_block;
     VkDescriptorSet desc_set;
     VkDescriptorPool desc_pool;
+    VkPipelineBindPoint pipeline_bind_point;
     GpuBufferInfo(GpuDeviceMemoryBlock output_mem_block, GpuDeviceMemoryBlock input_mem_block, VkDescriptorSet desc_set,
-                  VkDescriptorPool desc_pool)
-        : output_mem_block(output_mem_block), input_mem_block(input_mem_block), desc_set(desc_set), desc_pool(desc_pool){};
+                  VkDescriptorPool desc_pool, VkPipelineBindPoint pipeline_bind_point)
+        : output_mem_block(output_mem_block),
+          input_mem_block(input_mem_block),
+          desc_set(desc_set),
+          desc_pool(desc_pool),
+          pipeline_bind_point(pipeline_bind_point){};
+};
+
+struct GpuQueueBarrierCommandInfo {
+    VkCommandPool barrier_command_pool = VK_NULL_HANDLE;
+    VkCommandBuffer barrier_command_buffer = VK_NULL_HANDLE;
 };
 
 // Class to encapsulate Descriptor Set allocation.  This manager creates and destroys Descriptor Pools
@@ -69,20 +79,16 @@ struct GpuValidationState {
     uint32_t unique_shader_module_id;
     std::unordered_map<uint32_t, ShaderTracker> shader_map;
     std::unique_ptr<GpuDescriptorSetManager> desc_set_manager;
-    VkCommandPool barrier_command_pool;
-    VkCommandBuffer barrier_command_buffer;
+    std::map<VkQueue, GpuQueueBarrierCommandInfo> queue_barrier_command_infos;
     std::unordered_map<VkCommandBuffer, std::vector<GpuBufferInfo>> command_buffer_map;  // gpu_buffer_list;
     uint32_t output_buffer_size;
     VmaAllocator vmaAllocator;
     PFN_vkSetDeviceLoaderData vkSetDeviceLoaderData;
     GpuValidationState(bool aborted = false, bool reserve_binding_slot = false, uint32_t unique_shader_module_id = 0,
-                       VkCommandPool barrier_command_pool = VK_NULL_HANDLE, VkCommandBuffer barrier_command_buffer = VK_NULL_HANDLE,
                        VmaAllocator vmaAllocator = {})
         : aborted(aborted),
           reserve_binding_slot(reserve_binding_slot),
           unique_shader_module_id(unique_shader_module_id),
-          barrier_command_pool(barrier_command_pool),
-          barrier_command_buffer(barrier_command_buffer),
           vmaAllocator(vmaAllocator){};
 
     std::vector<GpuBufferInfo> &GetGpuBufferInfo(const VkCommandBuffer command_buffer) {
diff --git a/layers/object_lifetime_validation.h b/layers/object_lifetime_validation.h
index bc12f8c85..bd89dc889 100644
--- a/layers/object_lifetime_validation.h
+++ b/layers/object_lifetime_validation.h
@@ -20,6 +20,18 @@
  * Author: Tobin Ehlis <tobine@google.com>
  */
 
+// shared_mutex support added in MSVC 2015 update 2
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2
+#include <shared_mutex>
+typedef std::shared_mutex object_lifetime_mutex_t;
+typedef std::shared_lock<object_lifetime_mutex_t> read_object_lifetime_mutex_t;
+typedef std::unique_lock<object_lifetime_mutex_t> write_object_lifetime_mutex_t;
+#else
+typedef std::mutex object_lifetime_mutex_t;
+typedef std::unique_lock<object_lifetime_mutex_t> read_object_lifetime_mutex_t;
+typedef std::unique_lock<object_lifetime_mutex_t> write_object_lifetime_mutex_t;
+#endif
+
 // Suppress unused warning on Linux
 #if defined(__GNUC__)
 #define DECORATE_UNUSED __attribute__((unused))
@@ -42,14 +54,8 @@ extern uint64_t object_track_index;
 typedef VkFlags ObjectStatusFlags;
 enum ObjectStatusFlagBits {
     OBJSTATUS_NONE = 0x00000000,                      // No status is set
-    OBJSTATUS_FENCE_IS_SUBMITTED = 0x00000001,        // Fence has been submitted
-    OBJSTATUS_VIEWPORT_BOUND = 0x00000002,            // Viewport state object has been bound
-    OBJSTATUS_RASTER_BOUND = 0x00000004,              // Viewport state object has been bound
-    OBJSTATUS_COLOR_BLEND_BOUND = 0x00000008,         // Viewport state object has been bound
-    OBJSTATUS_DEPTH_STENCIL_BOUND = 0x00000010,       // Viewport state object has been bound
-    OBJSTATUS_GPU_MEM_MAPPED = 0x00000020,            // Memory object is currently mapped
-    OBJSTATUS_COMMAND_BUFFER_SECONDARY = 0x00000040,  // Command Buffer is of type SECONDARY
-    OBJSTATUS_CUSTOM_ALLOCATOR = 0x00000080,          // Allocated with custom allocator
+    OBJSTATUS_COMMAND_BUFFER_SECONDARY = 0x00000001,  // Command Buffer is of type SECONDARY
+    OBJSTATUS_CUSTOM_ALLOCATOR = 0x00000002,          // Allocated with custom allocator
 };
 
 // Object and state information structure
@@ -61,35 +67,49 @@ struct ObjTrackState {
     std::unique_ptr<std::unordered_set<uint64_t> > child_objects;  // Child objects (used for VkDescriptorPool only)
 };
 
-// Track Queue information
-struct ObjTrackQueueInfo {
-    uint32_t queue_node_index;
-    VkQueue queue;
-};
-
-typedef std::unordered_map<uint64_t, ObjTrackState *> object_map_type;
+typedef vl_concurrent_unordered_map<uint64_t, std::shared_ptr<ObjTrackState>, 6> object_map_type;
 
 class ObjectLifetimes : public ValidationObject {
    public:
-    uint64_t num_objects[kVulkanObjectTypeMax + 1];
-    uint64_t num_total_objects;
+    // Override chassis read/write locks for this validation object
+    // This override takes a deferred lock. i.e. it is not acquired.
+    // This class does its own locking with a shared mutex.
+    virtual std::unique_lock<std::mutex> write_lock() {
+        return std::unique_lock<std::mutex>(validation_object_mutex, std::defer_lock);
+    }
+
+    object_lifetime_mutex_t object_lifetime_mutex;
+    write_object_lifetime_mutex_t write_shared_lock() { return write_object_lifetime_mutex_t(object_lifetime_mutex); }
+    read_object_lifetime_mutex_t read_shared_lock() { return read_object_lifetime_mutex_t(object_lifetime_mutex); }
+
+    std::atomic<uint64_t> num_objects[kVulkanObjectTypeMax + 1];
+    std::atomic<uint64_t> num_total_objects;
     // Vector of unordered_maps per object type to hold ObjTrackState info
-    std::vector<object_map_type> object_map;
+    object_map_type object_map[kVulkanObjectTypeMax + 1];
     // Special-case map for swapchain images
-    std::unordered_map<uint64_t, ObjTrackState *> swapchainImageMap;
-    // Map of queue information structures, one per queue
-    std::unordered_map<VkQueue, ObjTrackQueueInfo *> queue_info_map;
-
-    std::vector<VkQueueFamilyProperties> queue_family_properties;
+    object_map_type swapchainImageMap;
 
     // Constructor for object lifetime tracking
-    ObjectLifetimes() : num_objects{}, num_total_objects(0), object_map{} { object_map.resize(kVulkanObjectTypeMax + 1); }
+    ObjectLifetimes() : num_objects{}, num_total_objects(0) {}
+
+    void InsertObject(object_map_type &map, uint64_t object_handle, VulkanObjectType object_type,
+                      std::shared_ptr<ObjTrackState> pNode) {
+        bool inserted = map.insert(object_handle, pNode);
+        if (!inserted) {
+            // The object should not already exist. If we couldn't add it to the map, there was probably
+            // a race condition in the app. Report an error and move on.
+            VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
+            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle, kVUID_ObjectTracker_Info,
+                    "Couldn't insert %s Object 0x%" PRIxLEAST64
+                    ", already existed. This should not happen and may indicate a "
+                    "race condition in the application.",
+                    object_string[object_type], object_handle);
+        }
+    }
 
     bool DeviceReportUndestroyedObjects(VkDevice device, VulkanObjectType object_type, const std::string &error_code);
     void DeviceDestroyUndestroyedObjects(VkDevice device, VulkanObjectType object_type);
     void CreateQueue(VkDevice device, VkQueue vkObj);
-    void AddQueueInfo(VkDevice device, uint32_t queue_node_index, VkQueue queue);
-    void ValidateQueueFlags(VkQueue queue, const char *function);
     void AllocateCommandBuffer(VkDevice device, const VkCommandPool command_pool, const VkCommandBuffer command_buffer,
                                VkCommandBufferLevel level);
     void AllocateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set);
@@ -129,7 +149,7 @@ class ObjectLifetimes : public ValidationObject {
         VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
 
         // Look for object in object map
-        if (object_map[object_type].find(object_handle) == object_map[object_type].end()) {
+        if (!object_map[object_type].contains(object_handle)) {
             // If object is an image, also look for it in the swapchain image map
             if ((object_type != kVulkanObjectTypeImage) || (swapchainImageMap.find(object_handle) == swapchainImageMap.end())) {
                 // Object not found, look for it in other device object maps
@@ -170,13 +190,13 @@ class ObjectLifetimes : public ValidationObject {
     void CreateObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type, const VkAllocationCallbacks *pAllocator) {
         uint64_t object_handle = HandleToUint64(object);
         bool custom_allocator = (pAllocator != nullptr);
-        if (!object_map[object_type].count(object_handle)) {
-            ObjTrackState *pNewObjNode = new ObjTrackState;
+        if (!object_map[object_type].contains(object_handle)) {
+            auto pNewObjNode = std::make_shared<ObjTrackState>();
             pNewObjNode->object_type = object_type;
             pNewObjNode->status = custom_allocator ? OBJSTATUS_CUSTOM_ALLOCATOR : OBJSTATUS_NONE;
             pNewObjNode->handle = object_handle;
 
-            object_map[object_type][object_handle] = pNewObjNode;
+            InsertObject(object_map[object_type], object_handle, object_type, pNewObjNode);
             num_objects[object_type]++;
             num_total_objects++;
 
@@ -191,27 +211,31 @@ class ObjectLifetimes : public ValidationObject {
         auto object_handle = HandleToUint64(object);
         assert(object_handle != VK_NULL_HANDLE);
 
-        auto item = object_map[object_type].find(object_handle);
-        assert(item != object_map[object_type].end());
-
-        ObjTrackState *pNode = item->second;
+        auto item = object_map[object_type].pop(object_handle);
+        if (item == object_map[object_type].end()) {
+            // We've already checked that the object exists. If we couldn't find and atomically remove it
+            // from the map, there must have been a race condition in the app. Report an error and move on.
+            VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
+            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, debug_object_type, object_handle, kVUID_ObjectTracker_Info,
+                    "Couldn't destroy %s Object 0x%" PRIxLEAST64
+                    ", not found. This should not happen and may indicate a "
+                    "race condition in the application.",
+                    object_string[object_type], object_handle);
+            return;
+        }
         assert(num_total_objects > 0);
 
         num_total_objects--;
-        assert(num_objects[pNode->object_type] > 0);
+        assert(num_objects[item->second->object_type] > 0);
 
-        num_objects[pNode->object_type]--;
-
-        delete pNode;
-        object_map[object_type].erase(item);
+        num_objects[item->second->object_type]--;
     }
 
     template <typename T1, typename T2>
     void RecordDestroyObject(T1 dispatchable_object, T2 object, VulkanObjectType object_type) {
         auto object_handle = HandleToUint64(object);
         if (object_handle != VK_NULL_HANDLE) {
-            auto item = object_map[object_type].find(object_handle);
-            if (item != object_map[object_type].end()) {
+            if (object_map[object_type].contains(object_handle)) {
                 DestroyObjectSilently(object, object_type);
             }
         }
@@ -226,11 +250,11 @@ class ObjectLifetimes : public ValidationObject {
         VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[object_type];
         bool skip = false;
 
-        if (object_handle != VK_NULL_HANDLE) {
+        if ((expected_custom_allocator_code != kVUIDUndefined || expected_default_allocator_code != kVUIDUndefined) &&
+            object_handle != VK_NULL_HANDLE) {
             auto item = object_map[object_type].find(object_handle);
             if (item != object_map[object_type].end()) {
-                ObjTrackState *pNode = item->second;
-                auto allocated_with_custom = (pNode->status & OBJSTATUS_CUSTOM_ALLOCATOR) ? true : false;
+                auto allocated_with_custom = (item->second->status & OBJSTATUS_CUSTOM_ALLOCATOR) ? true : false;
                 if (allocated_with_custom && !custom_allocator && expected_custom_allocator_code != kVUIDUndefined) {
                     // This check only verifies that custom allocation callbacks were provided to both Create and Destroy calls,
                     // it cannot verify that these allocation callbacks are compatible with each other.
diff --git a/layers/object_tracker_utils.cpp b/layers/object_tracker_utils.cpp
index 964f6e6f1..1b0eff903 100644
--- a/layers/object_tracker_utils.cpp
+++ b/layers/object_tracker_utils.cpp
@@ -34,56 +34,17 @@ VulkanTypedHandle ObjTrackStateTypedHandle(const ObjTrackState &track_state) {
     return typed_handle;
 }
 
-// Add new queue to head of global queue list
-void ObjectLifetimes::AddQueueInfo(VkDevice device, uint32_t queue_node_index, VkQueue queue) {
-    auto queueItem = queue_info_map.find(queue);
-    if (queueItem == queue_info_map.end()) {
-        ObjTrackQueueInfo *p_queue_info = new ObjTrackQueueInfo;
-        if (p_queue_info != NULL) {
-            memset(p_queue_info, 0, sizeof(ObjTrackQueueInfo));
-            p_queue_info->queue = queue;
-            p_queue_info->queue_node_index = queue_node_index;
-            queue_info_map[queue] = p_queue_info;
-        } else {
-            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(queue),
-                    kVUID_ObjectTracker_InternalError,
-                    "ERROR:  VK_ERROR_OUT_OF_HOST_MEMORY -- could not allocate memory for Queue Information");
-        }
-    }
-}
-
 // Destroy memRef lists and free all memory
 void ObjectLifetimes::DestroyQueueDataStructures(VkDevice device) {
-    for (auto queue_item : queue_info_map) {
-        delete queue_item.second;
-    }
-    queue_info_map.clear();
-
     // Destroy the items in the queue map
-    auto queue = object_map[kVulkanObjectTypeQueue].begin();
-    while (queue != object_map[kVulkanObjectTypeQueue].end()) {
-        uint32_t obj_index = queue->second->object_type;
+    auto snapshot = object_map[kVulkanObjectTypeQueue].snapshot();
+    for (const auto &queue : snapshot) {
+        uint32_t obj_index = queue.second->object_type;
         assert(num_total_objects > 0);
         num_total_objects--;
         assert(num_objects[obj_index] > 0);
         num_objects[obj_index]--;
-        delete queue->second;
-        queue = object_map[kVulkanObjectTypeQueue].erase(queue);
-    }
-}
-
-// Check Queue type flags for selected queue operations
-void ObjectLifetimes::ValidateQueueFlags(VkQueue queue, const char *function) {
-    auto queue_item = queue_info_map.find(queue);
-    if (queue_item != queue_info_map.end()) {
-        ObjTrackQueueInfo *pQueueInfo = queue_item->second;
-        if (pQueueInfo != NULL) {
-            if ((queue_family_properties[pQueueInfo->queue_node_index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) == 0) {
-                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT, HandleToUint64(queue),
-                        "VUID-vkQueueBindSparse-queuetype",
-                        "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_BINDING_BIT not set.", function);
-            }
-        }
+        object_map[kVulkanObjectTypeQueue].erase(queue.first);
     }
 }
 
@@ -94,8 +55,8 @@ bool ObjectLifetimes::ValidateDeviceObject(const VulkanTypedHandle &device_typed
                                            const char *wrong_device_code) {
     auto instance_data = GetLayerDataPtr(get_dispatch_key(instance), layer_data_map);
     auto instance_object_lifetime_data = GetObjectLifetimeData(instance_data->object_dispatch);
-    for (auto object : instance_object_lifetime_data->object_map[kVulkanObjectTypeDevice]) {
-        if (object.second->handle == device_typed.handle) return false;
+    if (instance_object_lifetime_data->object_map[kVulkanObjectTypeDevice].contains(device_typed.handle)) {
+        return false;
     }
     return log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT, device_typed.handle,
                    invalid_handle_code, "Invalid %s.", report_data->FormatHandle(device_typed).c_str());
@@ -103,7 +64,7 @@ bool ObjectLifetimes::ValidateDeviceObject(const VulkanTypedHandle &device_typed
 
 void ObjectLifetimes::AllocateCommandBuffer(VkDevice device, const VkCommandPool command_pool, const VkCommandBuffer command_buffer,
                                             VkCommandBufferLevel level) {
-    ObjTrackState *pNewObjNode = new ObjTrackState;
+    auto pNewObjNode = std::make_shared<ObjTrackState>();
     pNewObjNode->object_type = kVulkanObjectTypeCommandBuffer;
     pNewObjNode->handle = HandleToUint64(command_buffer);
     pNewObjNode->parent_object = HandleToUint64(command_pool);
@@ -112,7 +73,8 @@ void ObjectLifetimes::AllocateCommandBuffer(VkDevice device, const VkCommandPool
     } else {
         pNewObjNode->status = OBJSTATUS_NONE;
     }
-    object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)] = pNewObjNode;
+    InsertObject(object_map[kVulkanObjectTypeCommandBuffer], HandleToUint64(command_buffer), kVulkanObjectTypeCommandBuffer,
+                 pNewObjNode);
     num_objects[kVulkanObjectTypeCommandBuffer]++;
     num_total_objects++;
 }
@@ -120,8 +82,9 @@ void ObjectLifetimes::AllocateCommandBuffer(VkDevice device, const VkCommandPool
 bool ObjectLifetimes::ValidateCommandBuffer(VkDevice device, VkCommandPool command_pool, VkCommandBuffer command_buffer) {
     bool skip = false;
     uint64_t object_handle = HandleToUint64(command_buffer);
-    if (object_map[kVulkanObjectTypeCommandBuffer].find(object_handle) != object_map[kVulkanObjectTypeCommandBuffer].end()) {
-        ObjTrackState *pNode = object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
+    auto iter = object_map[kVulkanObjectTypeCommandBuffer].find(object_handle);
+    if (iter != object_map[kVulkanObjectTypeCommandBuffer].end()) {
+        auto pNode = iter->second;
 
         if (pNode->parent_object != HandleToUint64(command_pool)) {
             // We know that the parent *must* be a command pool
@@ -141,19 +104,19 @@ bool ObjectLifetimes::ValidateCommandBuffer(VkDevice device, VkCommandPool comma
 }
 
 void ObjectLifetimes::AllocateDescriptorSet(VkDevice device, VkDescriptorPool descriptor_pool, VkDescriptorSet descriptor_set) {
-    ObjTrackState *pNewObjNode = new ObjTrackState;
+    auto pNewObjNode = std::make_shared<ObjTrackState>();
     pNewObjNode->object_type = kVulkanObjectTypeDescriptorSet;
     pNewObjNode->status = OBJSTATUS_NONE;
     pNewObjNode->handle = HandleToUint64(descriptor_set);
     pNewObjNode->parent_object = HandleToUint64(descriptor_pool);
-    object_map[kVulkanObjectTypeDescriptorSet][HandleToUint64(descriptor_set)] = pNewObjNode;
+    InsertObject(object_map[kVulkanObjectTypeDescriptorSet], HandleToUint64(descriptor_set), kVulkanObjectTypeDescriptorSet,
+                 pNewObjNode);
     num_objects[kVulkanObjectTypeDescriptorSet]++;
     num_total_objects++;
 
     auto itr = object_map[kVulkanObjectTypeDescriptorPool].find(HandleToUint64(descriptor_pool));
     if (itr != object_map[kVulkanObjectTypeDescriptorPool].end()) {
-        ObjTrackState *pPoolNode = itr->second;
-        pPoolNode->child_objects->insert(HandleToUint64(descriptor_set));
+        itr->second->child_objects->insert(HandleToUint64(descriptor_set));
     }
 }
 
@@ -162,11 +125,9 @@ bool ObjectLifetimes::ValidateDescriptorSet(VkDevice device, VkDescriptorPool de
     uint64_t object_handle = HandleToUint64(descriptor_set);
     auto dsItem = object_map[kVulkanObjectTypeDescriptorSet].find(object_handle);
     if (dsItem != object_map[kVulkanObjectTypeDescriptorSet].end()) {
-        ObjTrackState *pNode = dsItem->second;
-
-        if (pNode->parent_object != HandleToUint64(descriptor_pool)) {
+        if (dsItem->second->parent_object != HandleToUint64(descriptor_pool)) {
             // We know that the parent *must* be a descriptor pool
-            const auto parent_pool = CastFromUint64<VkDescriptorPool>(pNode->parent_object);
+            const auto parent_pool = CastFromUint64<VkDescriptorPool>(dsItem->second->parent_object);
             skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
                             object_handle, "VUID-vkFreeDescriptorSets-pDescriptorSets-parent",
                             "FreeDescriptorSets is attempting to free %s"
@@ -240,11 +201,11 @@ bool ObjectLifetimes::PreCallValidateCmdPushDescriptorSetKHR(VkCommandBuffer com
 }
 
 void ObjectLifetimes::CreateQueue(VkDevice device, VkQueue vkObj) {
-    ObjTrackState *p_obj_node = NULL;
+    std::shared_ptr<ObjTrackState> p_obj_node = NULL;
     auto queue_item = object_map[kVulkanObjectTypeQueue].find(HandleToUint64(vkObj));
     if (queue_item == object_map[kVulkanObjectTypeQueue].end()) {
-        p_obj_node = new ObjTrackState;
-        object_map[kVulkanObjectTypeQueue][HandleToUint64(vkObj)] = p_obj_node;
+        p_obj_node = std::make_shared<ObjTrackState>();
+        InsertObject(object_map[kVulkanObjectTypeQueue], HandleToUint64(vkObj), kVulkanObjectTypeQueue, p_obj_node);
         num_objects[kVulkanObjectTypeQueue]++;
         num_total_objects++;
     } else {
@@ -256,18 +217,22 @@ void ObjectLifetimes::CreateQueue(VkDevice device, VkQueue vkObj) {
 }
 
 void ObjectLifetimes::CreateSwapchainImageObject(VkDevice dispatchable_object, VkImage swapchain_image, VkSwapchainKHR swapchain) {
-    ObjTrackState *pNewObjNode = new ObjTrackState;
-    pNewObjNode->object_type = kVulkanObjectTypeImage;
-    pNewObjNode->status = OBJSTATUS_NONE;
-    pNewObjNode->handle = HandleToUint64(swapchain_image);
-    pNewObjNode->parent_object = HandleToUint64(swapchain);
-    swapchainImageMap[HandleToUint64(swapchain_image)] = pNewObjNode;
+    if (!swapchainImageMap.contains(HandleToUint64(swapchain_image))) {
+        auto pNewObjNode = std::make_shared<ObjTrackState>();
+        pNewObjNode->object_type = kVulkanObjectTypeImage;
+        pNewObjNode->status = OBJSTATUS_NONE;
+        pNewObjNode->handle = HandleToUint64(swapchain_image);
+        pNewObjNode->parent_object = HandleToUint64(swapchain);
+        InsertObject(swapchainImageMap, HandleToUint64(swapchain_image), kVulkanObjectTypeImage, pNewObjNode);
+    }
 }
 
 bool ObjectLifetimes::DeviceReportUndestroyedObjects(VkDevice device, VulkanObjectType object_type, const std::string &error_code) {
     bool skip = false;
-    for (const auto &item : object_map[object_type]) {
-        const ObjTrackState *object_info = item.second;
+
+    auto snapshot = object_map[object_type].snapshot();
+    for (const auto &item : snapshot) {
+        const auto object_info = item.second;
         skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, get_debug_report_enum[object_type], object_info->handle,
                         error_code, "OBJ ERROR : For %s, %s has not been destroyed.", report_data->FormatHandle(device).c_str(),
                         report_data->FormatHandle(ObjTrackStateTypedHandle(*object_info)).c_str());
@@ -276,10 +241,9 @@ bool ObjectLifetimes::DeviceReportUndestroyedObjects(VkDevice device, VulkanObje
 }
 
 void ObjectLifetimes::DeviceDestroyUndestroyedObjects(VkDevice device, VulkanObjectType object_type) {
-    while (!object_map[object_type].empty()) {
-        auto item = object_map[object_type].begin();
-
-        ObjTrackState *object_info = item->second;
+    auto snapshot = object_map[object_type].snapshot();
+    for (const auto &item : snapshot) {
+        auto object_info = item.second;
         DestroyObjectSilently(object_info->handle, object_type);
     }
 }
@@ -292,8 +256,9 @@ bool ObjectLifetimes::PreCallValidateDestroyInstance(VkInstance instance, const
                            kVUIDUndefined);
 
     // Validate that child devices have been destroyed
-    for (const auto &iit : object_map[kVulkanObjectTypeDevice]) {
-        ObjTrackState *pNode = iit.second;
+    auto snapshot = object_map[kVulkanObjectTypeDevice].snapshot();
+    for (const auto &iit : snapshot) {
+        auto pNode = iit.second;
 
         VkDevice device = reinterpret_cast<VkDevice>(pNode->handle);
         VkDebugReportObjectTypeEXT debug_object_type = get_debug_report_enum[pNode->object_type];
@@ -335,25 +300,22 @@ void ObjectLifetimes::PostCallRecordEnumeratePhysicalDevices(VkInstance instance
 
 void ObjectLifetimes::PreCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
     // Destroy physical devices
-    for (auto iit = object_map[kVulkanObjectTypePhysicalDevice].begin();
-         iit != object_map[kVulkanObjectTypePhysicalDevice].end();) {
-        ObjTrackState *pNode = iit->second;
+    auto snapshot = object_map[kVulkanObjectTypePhysicalDevice].snapshot();
+    for (const auto &iit : snapshot) {
+        auto pNode = iit.second;
         VkPhysicalDevice physical_device = reinterpret_cast<VkPhysicalDevice>(pNode->handle);
         RecordDestroyObject(instance, physical_device, kVulkanObjectTypePhysicalDevice);
-        iit = object_map[kVulkanObjectTypePhysicalDevice].begin();
     }
 
     // Destroy child devices
-    for (auto iit = object_map[kVulkanObjectTypeDevice].begin(); iit != object_map[kVulkanObjectTypeDevice].end();) {
-        ObjTrackState *pNode = iit->second;
+    auto snapshot2 = object_map[kVulkanObjectTypeDevice].snapshot();
+    for (const auto &iit : snapshot2) {
+        auto pNode = iit.second;
         VkDevice device = reinterpret_cast<VkDevice>(pNode->handle);
         DestroyUndestroyedObjects(device);
 
         RecordDestroyObject(instance, device, kVulkanObjectTypeDevice);
-        iit = object_map[kVulkanObjectTypeDevice].begin();
     }
-
-    object_map[kVulkanObjectTypeDevice].clear();
 }
 
 void ObjectLifetimes::PostCallRecordDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) {
@@ -392,8 +354,8 @@ bool ObjectLifetimes::PreCallValidateGetDeviceQueue(VkDevice device, uint32_t qu
 
 void ObjectLifetimes::PostCallRecordGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex,
                                                    VkQueue *pQueue) {
+    auto lock = write_shared_lock();
     CreateQueue(device, *pQueue);
-    AddQueueInfo(device, queueFamilyIndex, *pQueue);
 }
 
 bool ObjectLifetimes::PreCallValidateGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
@@ -402,8 +364,8 @@ bool ObjectLifetimes::PreCallValidateGetDeviceQueue2(VkDevice device, const VkDe
 }
 
 void ObjectLifetimes::PostCallRecordGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) {
+    auto lock = write_shared_lock();
     CreateQueue(device, *pQueue);
-    AddQueueInfo(device, pQueueInfo->queueFamilyIndex, *pQueue);
 }
 
 bool ObjectLifetimes::PreCallValidateUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
@@ -436,6 +398,7 @@ bool ObjectLifetimes::PreCallValidateUpdateDescriptorSets(VkDevice device, uint3
 bool ObjectLifetimes::PreCallValidateResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                                          VkDescriptorPoolResetFlags flags) {
     bool skip = false;
+    auto lock = read_shared_lock();
 
     skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkResetDescriptorPool-device-parameter",
                            kVUIDUndefined);
@@ -445,7 +408,7 @@ bool ObjectLifetimes::PreCallValidateResetDescriptorPool(VkDevice device, VkDesc
 
     auto itr = object_map[kVulkanObjectTypeDescriptorPool].find(HandleToUint64(descriptorPool));
     if (itr != object_map[kVulkanObjectTypeDescriptorPool].end()) {
-        ObjTrackState *pPoolNode = itr->second;
+        auto pPoolNode = itr->second;
         for (auto set : *pPoolNode->child_objects) {
             skip |= ValidateDestroyObject(device, (VkDescriptorSet)set, kVulkanObjectTypeDescriptorSet, nullptr, kVUIDUndefined,
                                           kVUIDUndefined);
@@ -456,11 +419,12 @@ bool ObjectLifetimes::PreCallValidateResetDescriptorPool(VkDevice device, VkDesc
 
 void ObjectLifetimes::PreCallRecordResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                                        VkDescriptorPoolResetFlags flags) {
+    auto lock = write_shared_lock();
     // A DescriptorPool's descriptor sets are implicitly deleted when the pool is reset. Remove this pool's descriptor sets from
     // our descriptorSet map.
     auto itr = object_map[kVulkanObjectTypeDescriptorPool].find(HandleToUint64(descriptorPool));
     if (itr != object_map[kVulkanObjectTypeDescriptorPool].end()) {
-        ObjTrackState *pPoolNode = itr->second;
+        auto pPoolNode = itr->second;
         for (auto set : *pPoolNode->child_objects) {
             RecordDestroyObject(device, (VkDescriptorSet)set, kVulkanObjectTypeDescriptorSet);
         }
@@ -474,13 +438,18 @@ bool ObjectLifetimes::PreCallValidateBeginCommandBuffer(VkCommandBuffer command_
     skip |= ValidateObject(command_buffer, command_buffer, kVulkanObjectTypeCommandBuffer, false,
                            "VUID-vkBeginCommandBuffer-commandBuffer-parameter", kVUIDUndefined);
     if (begin_info) {
-        ObjTrackState *pNode = object_map[kVulkanObjectTypeCommandBuffer][HandleToUint64(command_buffer)];
-        if ((begin_info->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY) &&
-            (begin_info->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) {
-            skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer, kVulkanObjectTypeFramebuffer, true,
+        auto iter = object_map[kVulkanObjectTypeCommandBuffer].find(HandleToUint64(command_buffer));
+        if (iter != object_map[kVulkanObjectTypeCommandBuffer].end()) {
+            auto pNode = iter->second;
+            if ((begin_info->pInheritanceInfo) && (pNode->status & OBJSTATUS_COMMAND_BUFFER_SECONDARY) &&
+                (begin_info->flags & VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT)) {
+                skip |=
+                    ValidateObject(command_buffer, begin_info->pInheritanceInfo->framebuffer, kVulkanObjectTypeFramebuffer, true,
                                    "VUID-VkCommandBufferBeginInfo-flags-00055", "VUID-VkCommandBufferInheritanceInfo-commonparent");
-            skip |= ValidateObject(command_buffer, begin_info->pInheritanceInfo->renderPass, kVulkanObjectTypeRenderPass, false,
+                skip |=
+                    ValidateObject(command_buffer, begin_info->pInheritanceInfo->renderPass, kVulkanObjectTypeRenderPass, false,
                                    "VUID-VkCommandBufferBeginInfo-flags-00053", "VUID-VkCommandBufferInheritanceInfo-commonparent");
+            }
         }
     }
     return skip;
@@ -499,6 +468,7 @@ bool ObjectLifetimes::PreCallValidateGetSwapchainImagesKHR(VkDevice device, VkSw
 void ObjectLifetimes::PostCallRecordGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pSwapchainImageCount,
                                                           VkImage *pSwapchainImages, VkResult result) {
     if ((result != VK_SUCCESS) && (result != VK_INCOMPLETE)) return;
+    auto lock = write_shared_lock();
     if (pSwapchainImages != NULL) {
         for (uint32_t i = 0; i < *pSwapchainImageCount; i++) {
             CreateSwapchainImageObject(device, pSwapchainImages[i], swapchain);
@@ -584,16 +554,7 @@ bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceQueueFamilyProperties(VkPh
 
 void ObjectLifetimes::PostCallRecordGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice,
                                                                            uint32_t *pQueueFamilyPropertyCount,
-                                                                           VkQueueFamilyProperties *pQueueFamilyProperties) {
-    if (pQueueFamilyProperties != NULL) {
-        if (queue_family_properties.size() < *pQueueFamilyPropertyCount) {
-            queue_family_properties.resize(*pQueueFamilyPropertyCount);
-        }
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
-            queue_family_properties[i] = pQueueFamilyProperties[i];
-        }
-    }
-}
+                                                                           VkQueueFamilyProperties *pQueueFamilyProperties) {}
 
 void ObjectLifetimes::PostCallRecordCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
                                                    VkInstance *pInstance, VkResult result) {
@@ -622,6 +583,7 @@ void ObjectLifetimes::PostCallRecordAllocateCommandBuffers(VkDevice device, cons
 bool ObjectLifetimes::PreCallValidateAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
                                                             VkDescriptorSet *pDescriptorSets) {
     bool skip = false;
+    auto lock = read_shared_lock();
     skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkAllocateDescriptorSets-device-parameter",
                            kVUIDUndefined);
     skip |= ValidateObject(device, pAllocateInfo->descriptorPool, kVulkanObjectTypeDescriptorPool, false,
@@ -638,6 +600,7 @@ bool ObjectLifetimes::PreCallValidateAllocateDescriptorSets(VkDevice device, con
 void ObjectLifetimes::PostCallRecordAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo *pAllocateInfo,
                                                            VkDescriptorSet *pDescriptorSets, VkResult result) {
     if (result != VK_SUCCESS) return;
+    auto lock = write_shared_lock();
     for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++) {
         AllocateDescriptorSet(device, pAllocateInfo->descriptorPool, pDescriptorSets[i]);
     }
@@ -676,21 +639,17 @@ bool ObjectLifetimes::PreCallValidateDestroySwapchainKHR(VkDevice device, VkSwap
 void ObjectLifetimes::PreCallRecordDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain,
                                                        const VkAllocationCallbacks *pAllocator) {
     RecordDestroyObject(device, swapchain, kVulkanObjectTypeSwapchainKHR);
-    std::unordered_map<uint64_t, ObjTrackState *>::iterator itr = swapchainImageMap.begin();
-    while (itr != swapchainImageMap.end()) {
-        ObjTrackState *pNode = (*itr).second;
-        if (pNode->parent_object == HandleToUint64(swapchain)) {
-            delete pNode;
-            auto delete_item = itr++;
-            swapchainImageMap.erase(delete_item);
-        } else {
-            ++itr;
-        }
+
+    auto snapshot = swapchainImageMap.snapshot(
+        [swapchain](std::shared_ptr<ObjTrackState> pNode) { return pNode->parent_object == HandleToUint64(swapchain); });
+    for (const auto &itr : snapshot) {
+        swapchainImageMap.erase(itr.first);
     }
 }
 
 bool ObjectLifetimes::PreCallValidateFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
                                                         uint32_t descriptorSetCount, const VkDescriptorSet *pDescriptorSets) {
+    auto lock = read_shared_lock();
     bool skip = false;
     skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkFreeDescriptorSets-device-parameter",
                            kVUIDUndefined);
@@ -707,7 +666,8 @@ bool ObjectLifetimes::PreCallValidateFreeDescriptorSets(VkDevice device, VkDescr
 }
 void ObjectLifetimes::PreCallRecordFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount,
                                                       const VkDescriptorSet *pDescriptorSets) {
-    ObjTrackState *pPoolNode = nullptr;
+    auto lock = write_shared_lock();
+    std::shared_ptr<ObjTrackState> pPoolNode = nullptr;
     auto itr = object_map[kVulkanObjectTypeDescriptorPool].find(HandleToUint64(descriptorPool));
     if (itr != object_map[kVulkanObjectTypeDescriptorPool].end()) {
         pPoolNode = itr->second;
@@ -722,6 +682,7 @@ void ObjectLifetimes::PreCallRecordFreeDescriptorSets(VkDevice device, VkDescrip
 
 bool ObjectLifetimes::PreCallValidateDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                                            const VkAllocationCallbacks *pAllocator) {
+    auto lock = read_shared_lock();
     bool skip = false;
     skip |= ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkDestroyDescriptorPool-device-parameter",
                            kVUIDUndefined);
@@ -731,7 +692,7 @@ bool ObjectLifetimes::PreCallValidateDestroyDescriptorPool(VkDevice device, VkDe
 
     auto itr = object_map[kVulkanObjectTypeDescriptorPool].find(HandleToUint64(descriptorPool));
     if (itr != object_map[kVulkanObjectTypeDescriptorPool].end()) {
-        ObjTrackState *pPoolNode = itr->second;
+        auto pPoolNode = itr->second;
         for (auto set : *pPoolNode->child_objects) {
             skip |= ValidateDestroyObject(device, (VkDescriptorSet)set, kVulkanObjectTypeDescriptorSet, nullptr, kVUIDUndefined,
                                           kVUIDUndefined);
@@ -744,9 +705,10 @@ bool ObjectLifetimes::PreCallValidateDestroyDescriptorPool(VkDevice device, VkDe
 }
 void ObjectLifetimes::PreCallRecordDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
                                                          const VkAllocationCallbacks *pAllocator) {
+    auto lock = write_shared_lock();
     auto itr = object_map[kVulkanObjectTypeDescriptorPool].find(HandleToUint64(descriptorPool));
     if (itr != object_map[kVulkanObjectTypeDescriptorPool].end()) {
-        ObjTrackState *pPoolNode = itr->second;
+        auto pPoolNode = itr->second;
         for (auto set : *pPoolNode->child_objects) {
             RecordDestroyObject(device, (VkDescriptorSet)set, kVulkanObjectTypeDescriptorSet);
         }
@@ -762,16 +724,14 @@ bool ObjectLifetimes::PreCallValidateDestroyCommandPool(VkDevice device, VkComma
                            kVUIDUndefined);
     skip |= ValidateObject(device, commandPool, kVulkanObjectTypeCommandPool, true,
                            "VUID-vkDestroyCommandPool-commandPool-parameter", "VUID-vkDestroyCommandPool-commandPool-parent");
-    auto itr = object_map[kVulkanObjectTypeCommandBuffer].begin();
-    auto del_itr = itr;
-    while (itr != object_map[kVulkanObjectTypeCommandBuffer].end()) {
-        ObjTrackState *pNode = (*itr).second;
-        del_itr = itr++;
-        if (pNode->parent_object == HandleToUint64(commandPool)) {
-            skip |= ValidateCommandBuffer(device, commandPool, reinterpret_cast<VkCommandBuffer>((*del_itr).first));
-            skip |= ValidateDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first),
-                                          kVulkanObjectTypeCommandBuffer, nullptr, kVUIDUndefined, kVUIDUndefined);
-        }
+
+    auto snapshot = object_map[kVulkanObjectTypeCommandBuffer].snapshot(
+        [commandPool](std::shared_ptr<ObjTrackState> pNode) { return pNode->parent_object == HandleToUint64(commandPool); });
+    for (const auto &itr : snapshot) {
+        auto pNode = itr.second;
+        skip |= ValidateCommandBuffer(device, commandPool, reinterpret_cast<VkCommandBuffer>(itr.first));
+        skip |= ValidateDestroyObject(device, reinterpret_cast<VkCommandBuffer>(itr.first), kVulkanObjectTypeCommandBuffer, nullptr,
+                                      kVUIDUndefined, kVUIDUndefined);
     }
     skip |= ValidateDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool, pAllocator,
                                   "VUID-vkDestroyCommandPool-commandPool-00042", "VUID-vkDestroyCommandPool-commandPool-00043");
@@ -780,15 +740,11 @@ bool ObjectLifetimes::PreCallValidateDestroyCommandPool(VkDevice device, VkComma
 
 void ObjectLifetimes::PreCallRecordDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
                                                       const VkAllocationCallbacks *pAllocator) {
-    auto itr = object_map[kVulkanObjectTypeCommandBuffer].begin();
-    auto del_itr = itr;
+    auto snapshot = object_map[kVulkanObjectTypeCommandBuffer].snapshot(
+        [commandPool](std::shared_ptr<ObjTrackState> pNode) { return pNode->parent_object == HandleToUint64(commandPool); });
     // A CommandPool's cmd buffers are implicitly deleted when pool is deleted. Remove this pool's cmdBuffers from cmd buffer map.
-    while (itr != object_map[kVulkanObjectTypeCommandBuffer].end()) {
-        ObjTrackState *pNode = (*itr).second;
-        del_itr = itr++;
-        if (pNode->parent_object == HandleToUint64(commandPool)) {
-            RecordDestroyObject(device, reinterpret_cast<VkCommandBuffer>((*del_itr).first), kVulkanObjectTypeCommandBuffer);
-        }
+    for (const auto &itr : snapshot) {
+        RecordDestroyObject(device, reinterpret_cast<VkCommandBuffer>(itr.first), kVulkanObjectTypeCommandBuffer);
     }
     RecordDestroyObject(device, commandPool, kVulkanObjectTypeCommandPool);
 }
@@ -809,28 +765,10 @@ bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceQueueFamilyProperties2KHR(
 
 void ObjectLifetimes::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice,
                                                                             uint32_t *pQueueFamilyPropertyCount,
-                                                                            VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
-    if (pQueueFamilyProperties != NULL) {
-        if (queue_family_properties.size() < *pQueueFamilyPropertyCount) {
-            queue_family_properties.resize(*pQueueFamilyPropertyCount);
-        }
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
-            queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
-        }
-    }
-}
+                                                                            VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {}
 
 void ObjectLifetimes::PostCallRecordGetPhysicalDeviceQueueFamilyProperties2KHR(
-    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {
-    if (pQueueFamilyProperties != NULL) {
-        if (queue_family_properties.size() < *pQueueFamilyPropertyCount) {
-            queue_family_properties.resize(*pQueueFamilyPropertyCount);
-        }
-        for (uint32_t i = 0; i < *pQueueFamilyPropertyCount; i++) {
-            queue_family_properties[i] = pQueueFamilyProperties[i].queueFamilyProperties;
-        }
-    }
-}
+    VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) {}
 
 bool ObjectLifetimes::PreCallValidateGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice,
                                                                            uint32_t *pPropertyCount,
@@ -938,3 +876,29 @@ bool ObjectLifetimes::PreCallValidateQueueSetPerformanceConfigurationINTEL(VkQue
 
     return skip;
 }
+
+bool ObjectLifetimes::PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
+                                                       const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer) {
+    bool skip = false;
+    skip |=
+        ValidateObject(device, device, kVulkanObjectTypeDevice, false, "VUID-vkCreateFramebuffer-device-parameter", kVUIDUndefined);
+    if (pCreateInfo) {
+        skip |= ValidateObject(device, pCreateInfo->renderPass, kVulkanObjectTypeRenderPass, false,
+                               "VUID-VkFramebufferCreateInfo-renderPass-parameter", "VUID-VkFramebufferCreateInfo-commonparent");
+        if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
+            for (uint32_t index1 = 0; index1 < pCreateInfo->attachmentCount; ++index1) {
+                skip |= ValidateObject(device, pCreateInfo->pAttachments[index1], kVulkanObjectTypeImageView, true, kVUIDUndefined,
+                                       "VUID-VkFramebufferCreateInfo-commonparent");
+            }
+        }
+    }
+
+    return skip;
+}
+
+void ObjectLifetimes::PostCallRecordCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
+                                                      const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer,
+                                                      VkResult result) {
+    if (result != VK_SUCCESS) return;
+    CreateObject(device, *pFramebuffer, kVulkanObjectTypeFramebuffer, pAllocator);
+}
diff --git a/layers/parameter_validation_utils.cpp b/layers/parameter_validation_utils.cpp
index 3ed6157ea..102509ca5 100644
--- a/layers/parameter_validation_utils.cpp
+++ b/layers/parameter_validation_utils.cpp
@@ -115,6 +115,21 @@ void StatelessValidation::PostCallRecordCreateInstance(const VkInstanceCreateInf
     this->instance_extensions = instance_data->instance_extensions;
 }
 
+void StatelessValidation::PostCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo, VkResult result) {
+    for (uint32_t i = 0; i < pPresentInfo->swapchainCount; ++i) {
+        auto swapchains_result = pPresentInfo->pResults ? pPresentInfo->pResults[i] : result;
+        if (swapchains_result == VK_SUBOPTIMAL_KHR) {
+            log_msg(report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
+                    HandleToUint64(pPresentInfo->pSwapchains[i]), kVUID_PVPerfWarn_SuboptimalSwapchain,
+                    "vkQueuePresentKHR: %s :VK_SUBOPTIMAL_KHR was returned. VK_SUBOPTIMAL_KHR - Presentation will still succeed, "
+                    "subject to the window resize behavior, but the swapchain is no longer configured optimally for the surface it "
+                    "targets. Applications should query updated surface information and recreate their swapchain at the next "
+                    "convenient opportunity.",
+                    report_data->FormatHandle(pPresentInfo->pSwapchains[i]).c_str());
+        }
+    }
+}
+
 void StatelessValidation::PostCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
                                                      const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, VkResult result) {
     auto device_data = GetLayerDataPtr(get_dispatch_key(*pDevice), layer_data_map);
@@ -158,18 +173,19 @@ void StatelessValidation::PostCallRecordCreateDevice(VkPhysicalDevice physicalDe
 
     // Save app-enabled features in this device's validation object
     // The enabled features can come from either pEnabledFeatures, or from the pNext chain
-    const VkPhysicalDeviceFeatures *enabled_features_found = pCreateInfo->pEnabledFeatures;
-    if ((nullptr == enabled_features_found) && device_extensions.vk_khr_get_physical_device_properties_2) {
-        const auto *features2 = lvl_find_in_chain<VkPhysicalDeviceFeatures2KHR>(pCreateInfo->pNext);
-        if (features2) {
-            enabled_features_found = &(features2->features);
-        }
-    }
-    if (enabled_features_found) {
-        stateless_validation->physical_device_features = *enabled_features_found;
+    const auto *features2 = lvl_find_in_chain<VkPhysicalDeviceFeatures2>(pCreateInfo->pNext);
+    safe_VkPhysicalDeviceFeatures2 tmp_features2_state;
+    tmp_features2_state.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+    if (features2) {
+        tmp_features2_state.features = features2->features;
+    } else if (pCreateInfo->pEnabledFeatures) {
+        tmp_features2_state.features = *pCreateInfo->pEnabledFeatures;
     } else {
-        memset(&stateless_validation->physical_device_features, 0, sizeof(VkPhysicalDeviceFeatures));
+        tmp_features2_state.features = {};
     }
+    // Use pCreateInfo->pNext to get full chain
+    tmp_features2_state.pNext = SafePnextCopy(pCreateInfo->pNext);
+    stateless_validation->physical_device_features2 = tmp_features2_state;
 }
 
 bool StatelessValidation::manual_PreCallValidateCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo,
@@ -620,32 +636,6 @@ bool StatelessValidation::manual_PreCallValidateCreateImage(VkDevice device, con
     return skip;
 }
 
-bool StatelessValidation::manual_PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
-                                                                const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
-    bool skip = false;
-
-    if (pCreateInfo != nullptr) {
-        // Validate chained VkImageViewUsageCreateInfo struct, if present
-        if (nullptr != pCreateInfo->pNext) {
-            auto chained_ivuci_struct = lvl_find_in_chain<VkImageViewUsageCreateInfoKHR>(pCreateInfo->pNext);
-            if (chained_ivuci_struct) {
-                if (0 == chained_ivuci_struct->usage) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                    "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask",
-                                    "vkCreateImageView: Chained VkImageViewUsageCreateInfo usage field must not be 0.");
-                } else if (chained_ivuci_struct->usage & ~AllVkImageUsageFlagBits) {
-                    std::stringstream ss;
-                    ss << "vkCreateImageView: Chained VkImageViewUsageCreateInfo usage field (0x" << std::hex
-                       << chained_ivuci_struct->usage << ") contains invalid flag bits.";
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                    "VUID-VkImageViewUsageCreateInfo-usage-parameter", "%s", ss.str().c_str());
-                }
-            }
-        }
-    }
-    return skip;
-}
-
 bool StatelessValidation::manual_PreCallValidateViewport(const VkViewport &viewport, const char *fn_name,
                                                          const ParameterName &parameter_name,
                                                          VkDebugReportObjectTypeEXT object_type, uint64_t object = 0) {
@@ -927,6 +917,7 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
             bool has_dynamic_sample_locations_ext = false;
             bool has_dynamic_exclusive_scissor_nv = false;
             bool has_dynamic_shading_rate_palette_nv = false;
+            bool has_dynamic_line_stipple = false;
             if (pCreateInfos[i].pDynamicState != nullptr) {
                 const auto &dynamic_state_info = *pCreateInfos[i].pDynamicState;
                 for (uint32_t state_index = 0; state_index < dynamic_state_info.dynamicStateCount; ++state_index) {
@@ -940,6 +931,7 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
                     if (dynamic_state == VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV) has_dynamic_exclusive_scissor_nv = true;
                     if (dynamic_state == VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV)
                         has_dynamic_shading_rate_palette_nv = true;
+                    if (dynamic_state == VK_DYNAMIC_STATE_LINE_STIPPLE_EXT) has_dynamic_line_stipple = true;
                 }
             }
 
@@ -956,9 +948,121 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
             }
 
             // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
-            if (pCreateInfos[i].pVertexInputState != nullptr) {
+
+            // Collect active stages
+            uint32_t active_shaders = 0;
+            for (uint32_t stages = 0; stages < pCreateInfos[i].stageCount; stages++) {
+                active_shaders |= pCreateInfos[i].pStages->stage;
+            }
+
+            if ((active_shaders & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) &&
+                (active_shaders & VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT) && (pCreateInfos[i].pTessellationState != nullptr)) {
+                skip |= validate_struct_type("vkCreateGraphicsPipelines", "pCreateInfos[i].pTessellationState",
+                                             "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO",
+                                             pCreateInfos[i].pTessellationState,
+                                             VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, false, kVUIDUndefined,
+                                             "VUID-VkPipelineTessellationStateCreateInfo-sType-sType");
+
+                const VkStructureType allowed_structs_VkPipelineTessellationStateCreateInfo[] = {
+                    VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO};
+
+                skip |= validate_struct_pnext("vkCreateGraphicsPipelines", "pCreateInfos[i].pTessellationState->pNext",
+                                              "VkPipelineTessellationDomainOriginStateCreateInfo",
+                                              pCreateInfos[i].pTessellationState->pNext,
+                                              ARRAY_SIZE(allowed_structs_VkPipelineTessellationStateCreateInfo),
+                                              allowed_structs_VkPipelineTessellationStateCreateInfo, GeneratedVulkanHeaderVersion,
+                                              "VUID-VkPipelineTessellationStateCreateInfo-pNext-pNext");
+
+                skip |= validate_reserved_flags("vkCreateGraphicsPipelines", "pCreateInfos[i].pTessellationState->flags",
+                                                pCreateInfos[i].pTessellationState->flags,
+                                                "VUID-VkPipelineTessellationStateCreateInfo-flags-zerobitmask");
+            }
+
+            if (!(active_shaders & VK_SHADER_STAGE_MESH_BIT_NV) && (pCreateInfos[i].pInputAssemblyState != nullptr)) {
+                skip |= validate_struct_type("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState",
+                                             "VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO",
+                                             pCreateInfos[i].pInputAssemblyState,
+                                             VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, false, kVUIDUndefined,
+                                             "VUID-VkPipelineInputAssemblyStateCreateInfo-sType-sType");
+
+                skip |= validate_struct_pnext("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->pNext", NULL,
+                                              pCreateInfos[i].pInputAssemblyState->pNext, 0, NULL, GeneratedVulkanHeaderVersion,
+                                              "VUID-VkPipelineInputAssemblyStateCreateInfo-pNext-pNext");
+
+                skip |= validate_reserved_flags("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->flags",
+                                                pCreateInfos[i].pInputAssemblyState->flags,
+                                                "VUID-VkPipelineInputAssemblyStateCreateInfo-flags-zerobitmask");
+
+                skip |= validate_ranged_enum("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->topology",
+                                             "VkPrimitiveTopology", AllVkPrimitiveTopologyEnums,
+                                             pCreateInfos[i].pInputAssemblyState->topology,
+                                             "VUID-VkPipelineInputAssemblyStateCreateInfo-topology-parameter");
+
+                skip |= validate_bool32("vkCreateGraphicsPipelines", "pCreateInfos[i].pInputAssemblyState->primitiveRestartEnable",
+                                        pCreateInfos[i].pInputAssemblyState->primitiveRestartEnable);
+            }
+
+            if (!(active_shaders & VK_SHADER_STAGE_MESH_BIT_NV) && (pCreateInfos[i].pVertexInputState != nullptr)) {
                 auto const &vertex_input_state = pCreateInfos[i].pVertexInputState;
 
+                if (pCreateInfos[i].pVertexInputState->flags != 0) {
+                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkPipelineVertexInputStateCreateInfo-flags-zerobitmask",
+                                    "vkCreateGraphicsPipelines: pararameter "
+                                    "pCreateInfos[%d].pVertexInputState->flags (%u) is reserved and must be zero.",
+                                    i, vertex_input_state->flags);
+                }
+
+                const VkStructureType allowed_structs_VkPipelineVertexInputStateCreateInfo[] = {
+                    VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT};
+                skip |= validate_struct_pnext("vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState->pNext",
+                                              "VkPipelineVertexInputDivisorStateCreateInfoEXT",
+                                              pCreateInfos[i].pVertexInputState->pNext, 1,
+                                              allowed_structs_VkPipelineVertexInputStateCreateInfo, GeneratedVulkanHeaderVersion,
+                                              "VUID-VkPipelineVertexInputStateCreateInfo-pNext-pNext");
+                skip |= validate_struct_type("vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState",
+                                             "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO", vertex_input_state,
+                                             VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, false, kVUIDUndefined,
+                                             "VUID-VkPipelineVertexInputStateCreateInfo-sType-sType");
+                skip |=
+                    validate_array("vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState->vertexBindingDescriptionCount",
+                                   "pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions",
+                                   pCreateInfos[i].pVertexInputState->vertexBindingDescriptionCount,
+                                   &pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions, false, true, kVUIDUndefined,
+                                   "VUID-VkPipelineVertexInputStateCreateInfo-pVertexBindingDescriptions-parameter");
+
+                skip |= validate_array(
+                    "vkCreateGraphicsPipelines", "pCreateInfos[i].pVertexInputState->vertexAttributeDescriptionCount",
+                    "pCreateInfos[i]->pVertexAttributeDescriptions", vertex_input_state->vertexAttributeDescriptionCount,
+                    &vertex_input_state->pVertexAttributeDescriptions, false, true, kVUIDUndefined,
+                    "VUID-VkPipelineVertexInputStateCreateInfo-pVertexAttributeDescriptions-parameter");
+
+                if (pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions != NULL) {
+                    for (uint32_t vertexBindingDescriptionIndex = 0;
+                         vertexBindingDescriptionIndex < pCreateInfos[i].pVertexInputState->vertexBindingDescriptionCount;
+                         ++vertexBindingDescriptionIndex) {
+                        skip |= validate_ranged_enum(
+                            "vkCreateGraphicsPipelines",
+                            "pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions[j].inputRate", "VkVertexInputRate",
+                            AllVkVertexInputRateEnums,
+                            pCreateInfos[i].pVertexInputState->pVertexBindingDescriptions[vertexBindingDescriptionIndex].inputRate,
+                            "VUID-VkVertexInputBindingDescription-inputRate-parameter");
+                    }
+                }
+
+                if (pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions != NULL) {
+                    for (uint32_t vertexAttributeDescriptionIndex = 0;
+                         vertexAttributeDescriptionIndex < pCreateInfos[i].pVertexInputState->vertexAttributeDescriptionCount;
+                         ++vertexAttributeDescriptionIndex) {
+                        skip |= validate_ranged_enum(
+                            "vkCreateGraphicsPipelines",
+                            "pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions[i].format", "VkFormat",
+                            AllVkFormatEnums,
+                            pCreateInfos[i].pVertexInputState->pVertexAttributeDescriptions[vertexAttributeDescriptionIndex].format,
+                            "VUID-VkVertexInputAttributeDescription-format-parameter");
+                    }
+                }
+
                 if (vertex_input_state->vertexBindingDescriptionCount > device_limits.maxVertexInputBindings) {
                     skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                                     "VUID-VkPipelineVertexInputStateCreateInfo-vertexBindingDescriptionCount-00613",
@@ -1459,6 +1563,12 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
                         pCreateInfos[i].pMultisampleState->rasterizationSamples, &pCreateInfos[i].pMultisampleState->pSampleMask,
                         true, false, kVUIDUndefined, kVUIDUndefined);
 
+                    skip |= validate_flags(
+                        "vkCreateGraphicsPipelines",
+                        ParameterName("pCreateInfos[%i].pMultisampleState->rasterizationSamples", ParameterName::IndexVector{i}),
+                        "VkSampleCountFlagBits", AllVkSampleCountFlagBits, pCreateInfos[i].pMultisampleState->rasterizationSamples,
+                        kRequiredSingleBit, "VUID-VkPipelineMultisampleStateCreateInfo-rasterizationSamples-parameter");
+
                     skip |= validate_bool32(
                         "vkCreateGraphicsPipelines",
                         ParameterName("pCreateInfos[%i].pMultisampleState->alphaToCoverageEnable", ParameterName::IndexVector{i}),
@@ -1493,6 +1603,113 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
                                 "vkCreateGraphicsPipelines(): parameter pCreateInfos[%d].pMultisampleState->minSampleShading.", i);
                         }
                     }
+
+                    const auto *line_state = lvl_find_in_chain<VkPipelineRasterizationLineStateCreateInfoEXT>(
+                        pCreateInfos[i].pRasterizationState->pNext);
+
+                    if (line_state) {
+                        if ((line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT ||
+                             line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT)) {
+                            if (pCreateInfos[i].pMultisampleState->alphaToCoverageEnable) {
+                                skip |=
+                                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                            "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
+                                            "vkCreateGraphicsPipelines(): Bresenham/Smooth line rasterization not supported with "
+                                            "pCreateInfos[%d].pMultisampleState->alphaToCoverageEnable == VK_TRUE.",
+                                            i);
+                            }
+                            if (pCreateInfos[i].pMultisampleState->alphaToOneEnable) {
+                                skip |=
+                                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                            "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
+                                            "vkCreateGraphicsPipelines(): Bresenham/Smooth line rasterization not supported with "
+                                            "pCreateInfos[%d].pMultisampleState->alphaToOneEnable == VK_TRUE.",
+                                            i);
+                            }
+                            if (pCreateInfos[i].pMultisampleState->sampleShadingEnable) {
+                                skip |=
+                                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                            "VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
+                                            "vkCreateGraphicsPipelines(): Bresenham/Smooth line rasterization not supported with "
+                                            "pCreateInfos[%d].pMultisampleState->sampleShadingEnable == VK_TRUE.",
+                                            i);
+                            }
+                        }
+                        if (line_state->stippledLineEnable && !has_dynamic_line_stipple) {
+                            if (line_state->lineStippleFactor < 1 || line_state->lineStippleFactor > 256) {
+                                skip |=
+                                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                            "VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
+                                            "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineStippleFactor = %d must be in the "
+                                            "range [1,256].",
+                                            i, line_state->lineStippleFactor);
+                            }
+                        }
+                        const auto *line_features =
+                            lvl_find_in_chain<VkPhysicalDeviceLineRasterizationFeaturesEXT>(physical_device_features2.pNext);
+                        if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT &&
+                            (!line_features || !line_features->rectangularLines)) {
+                            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                            "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768",
+                                            "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
+                                            "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT requires the rectangularLines feature.",
+                                            i);
+                        }
+                        if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT &&
+                            (!line_features || !line_features->bresenhamLines)) {
+                            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                            "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769",
+                                            "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
+                                            "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT requires the bresenhamLines feature.",
+                                            i);
+                        }
+                        if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT &&
+                            (!line_features || !line_features->smoothLines)) {
+                            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                            "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770",
+                                            "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
+                                            "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT requires the smoothLines feature.",
+                                            i);
+                        }
+                        if (line_state->stippledLineEnable) {
+                            if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT &&
+                                (!line_features || !line_features->stippledRectangularLines)) {
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771",
+                                                "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
+                                                "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT with stipple requires the "
+                                                "stippledRectangularLines feature.",
+                                                i);
+                            }
+                            if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT &&
+                                (!line_features || !line_features->stippledBresenhamLines)) {
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772",
+                                                "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
+                                                "VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT with stipple requires the "
+                                                "stippledBresenhamLines feature.",
+                                                i);
+                            }
+                            if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT &&
+                                (!line_features || !line_features->stippledSmoothLines)) {
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773",
+                                                "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
+                                                "VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT with stipple requires the "
+                                                "stippledSmoothLines feature.",
+                                                i);
+                            }
+                            if (line_state->lineRasterizationMode == VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT &&
+                                (!line_features || !line_features->stippledSmoothLines || !device_limits.strictLines)) {
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774",
+                                                "vkCreateGraphicsPipelines(): pCreateInfos[%d] lineRasterizationMode = "
+                                                "VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT with stipple requires the "
+                                                "stippledRectangularLines and strictLines features.",
+                                                i);
+                            }
+                        }
+                    }
                 }
 
                 bool uses_color_attachment = false;
@@ -1609,6 +1826,13 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
                     VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT};
 
                 if (pCreateInfos[i].pColorBlendState != nullptr && uses_color_attachment) {
+                    skip |= validate_struct_type("vkCreateGraphicsPipelines",
+                                                 ParameterName("pCreateInfos[%i].pColorBlendState", ParameterName::IndexVector{i}),
+                                                 "VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO",
+                                                 pCreateInfos[i].pColorBlendState,
+                                                 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, false, kVUIDUndefined,
+                                                 "VUID-VkPipelineColorBlendStateCreateInfo-sType-sType");
+
                     skip |= validate_struct_pnext(
                         "vkCreateGraphicsPipelines",
                         ParameterName("pCreateInfos[%i].pColorBlendState->pNext", ParameterName::IndexVector{i}),
@@ -1696,7 +1920,7 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
                                                              ParameterName::IndexVector{i, attachmentIndex}),
                                                "VkColorComponentFlagBits", AllVkColorComponentFlagBits,
                                                pCreateInfos[i].pColorBlendState->pAttachments[attachmentIndex].colorWriteMask,
-                                               false, false, "VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter");
+                                               kOptionalFlags, "VUID-VkPipelineColorBlendAttachmentState-colorWriteMask-parameter");
                         }
                     }
 
@@ -1742,13 +1966,33 @@ bool StatelessValidation::manual_PreCallValidateCreateGraphicsPipelines(VkDevice
             }
 
             if (pCreateInfos[i].pRasterizationState) {
-                if ((pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL) &&
-                    (physical_device_features.fillModeNonSolid == false)) {
-                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                    kVUID_PVError_DeviceFeature,
+                if (!device_extensions.vk_nv_fill_rectangle) {
+                    if (pCreateInfos[i].pRasterizationState->polygonMode == VK_POLYGON_MODE_FILL_RECTANGLE_NV) {
+                        skip |=
+                            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414",
                                     "vkCreateGraphicsPipelines parameter, VkPolygonMode "
-                                    "pCreateInfos->pRasterizationState->polygonMode cannot be VK_POLYGON_MODE_POINT or "
-                                    "VK_POLYGON_MODE_LINE if VkPhysicalDeviceFeatures->fillModeNonSolid is false.");
+                                    "pCreateInfos->pRasterizationState->polygonMode cannot be VK_POLYGON_MODE_FILL_RECTANGLE_NV "
+                                    "if the extension VK_NV_fill_rectangle is not enabled.");
+                    } else if ((pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL) &&
+                               (physical_device_features.fillModeNonSolid == false)) {
+                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                        kVUID_PVError_DeviceFeature,
+                                        "vkCreateGraphicsPipelines parameter, VkPolygonMode "
+                                        "pCreateInfos->pRasterizationState->polygonMode cannot be VK_POLYGON_MODE_POINT or "
+                                        "VK_POLYGON_MODE_LINE if VkPhysicalDeviceFeatures->fillModeNonSolid is false.");
+                    }
+                } else {
+                    if ((pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL) &&
+                        (pCreateInfos[i].pRasterizationState->polygonMode != VK_POLYGON_MODE_FILL_RECTANGLE_NV) &&
+                        (physical_device_features.fillModeNonSolid == false)) {
+                        skip |=
+                            log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+                                    "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507",
+                                    "vkCreateGraphicsPipelines parameter, VkPolygonMode "
+                                    "pCreateInfos->pRasterizationState->polygonMode must be VK_POLYGON_MODE_FILL or "
+                                    "VK_POLYGON_MODE_FILL_RECTANGLE_NV if VkPhysicalDeviceFeatures->fillModeNonSolid is false.");
+                    }
                 }
 
                 if (!has_dynamic_line_width && !physical_device_features.wideLines &&
@@ -2130,44 +2374,69 @@ bool StatelessValidation::manual_PreCallValidateFreeCommandBuffers(VkDevice devi
 bool StatelessValidation::manual_PreCallValidateBeginCommandBuffer(VkCommandBuffer commandBuffer,
                                                                    const VkCommandBufferBeginInfo *pBeginInfo) {
     bool skip = false;
-    const VkCommandBufferInheritanceInfo *pInfo = pBeginInfo->pInheritanceInfo;
-
-    // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
-    // TODO: pBeginInfo->pInheritanceInfo must not be NULL if commandBuffer is a secondary command buffer
-    skip |= validate_struct_type("vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo",
-                                 "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO", pBeginInfo->pInheritanceInfo,
-                                 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, false,
-                                 "VUID_vkBeginCommandBuffer-pBeginInfo-parameter", "VUID_VkCommandBufferBeginInfo-sType-sType");
-
-    if (pBeginInfo->pInheritanceInfo != NULL) {
-        skip |= validate_struct_pnext("vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->pNext", NULL,
-                                      pBeginInfo->pInheritanceInfo->pNext, 0, NULL, GeneratedVulkanHeaderVersion,
-                                      "VUID-VkCommandBufferBeginInfo-pNext-pNext");
-
-        skip |= validate_bool32("vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->occlusionQueryEnable",
-                                pBeginInfo->pInheritanceInfo->occlusionQueryEnable);
 
-        // TODO: This only needs to be validated when the inherited queries feature is enabled
-        // skip |= validate_flags("vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->queryFlags",
-        // "VkQueryControlFlagBits", AllVkQueryControlFlagBits, pBeginInfo->pInheritanceInfo->queryFlags, false);
-
-        // TODO: This must be 0 if the pipeline statistics queries feature is not enabled
-        skip |= validate_flags("vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->pipelineStatistics",
-                               "VkQueryPipelineStatisticFlagBits", AllVkQueryPipelineStatisticFlagBits,
-                               pBeginInfo->pInheritanceInfo->pipelineStatistics, false, false, kVUIDUndefined);
-    }
+    // VkCommandBufferInheritanceInfo validation, due to a 'noautovalidity' of pBeginInfo->pInheritanceInfo in vkBeginCommandBuffer
+    const char *cmd_name = "vkBeginCommandBuffer";
+    const VkCommandBufferInheritanceInfo *pInfo = pBeginInfo->pInheritanceInfo;
 
-    if (pInfo != NULL) {
-        if ((physical_device_features.inheritedQueries == VK_FALSE) && (pInfo->occlusionQueryEnable != VK_FALSE)) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
-                            HandleToUint64(commandBuffer), "VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056",
-                            "Cannot set inherited occlusionQueryEnable in vkBeginCommandBuffer() when device does not support "
-                            "inheritedQueries.");
+    // Implicit VUs
+    // validate only sType here; pointer has to be validated in core_validation
+    const bool kNotRequired = false;
+    const char *kNoVUID = nullptr;
+    skip |= validate_struct_type(cmd_name, "pBeginInfo->pInheritanceInfo", "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO",
+                                 pInfo, VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO, kNotRequired, kNoVUID,
+                                 "VUID-VkCommandBufferInheritanceInfo-sType-sType");
+
+    if (pInfo) {
+        const VkStructureType allowed_structs_VkCommandBufferInheritanceInfo[] = {
+            VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT};
+        skip |= validate_struct_pnext(
+            cmd_name, "pBeginInfo->pInheritanceInfo->pNext", "VkCommandBufferInheritanceConditionalRenderingInfoEXT", pInfo->pNext,
+            ARRAY_SIZE(allowed_structs_VkCommandBufferInheritanceInfo), allowed_structs_VkCommandBufferInheritanceInfo,
+            GeneratedVulkanHeaderVersion, "VUID-VkCommandBufferInheritanceInfo-pNext-pNext");
+
+        skip |= validate_bool32(cmd_name, "pBeginInfo->pInheritanceInfo->occlusionQueryEnable", pInfo->occlusionQueryEnable);
+
+        // Explicit VUs
+        if (!physical_device_features.inheritedQueries && pInfo->occlusionQueryEnable == VK_TRUE) {
+            skip |= log_msg(
+                report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                HandleToUint64(commandBuffer), "VUID-VkCommandBufferInheritanceInfo-occlusionQueryEnable-00056",
+                "%s: Inherited queries feature is disabled, but pBeginInfo->pInheritanceInfo->occlusionQueryEnable is VK_TRUE.",
+                cmd_name);
         }
-        if ((physical_device_features.inheritedQueries != VK_FALSE) && (pInfo->occlusionQueryEnable != VK_FALSE)) {
-            skip |= validate_flags("vkBeginCommandBuffer", "pBeginInfo->pInheritanceInfo->queryFlags", "VkQueryControlFlagBits",
-                                   AllVkQueryControlFlagBits, pInfo->queryFlags, false, false,
+
+        if (physical_device_features.inheritedQueries) {
+            skip |= validate_flags(cmd_name, "pBeginInfo->pInheritanceInfo->queryFlags", "VkQueryControlFlagBits",
+                                   AllVkQueryControlFlagBits, pInfo->queryFlags, kOptionalFlags,
                                    "VUID-VkCommandBufferInheritanceInfo-queryFlags-00057");
+        } else {  // !inheritedQueries
+            skip |= validate_reserved_flags(cmd_name, "pBeginInfo->pInheritanceInfo->queryFlags", pInfo->queryFlags,
+                                            "VUID-VkCommandBufferInheritanceInfo-queryFlags-02788");
+        }
+
+        if (physical_device_features.pipelineStatisticsQuery) {
+            skip |= validate_flags(cmd_name, "pBeginInfo->pInheritanceInfo->pipelineStatistics", "VkQueryPipelineStatisticFlagBits",
+                                   AllVkQueryPipelineStatisticFlagBits, pInfo->pipelineStatistics, kOptionalFlags,
+                                   "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-02789");
+        } else {  // !pipelineStatisticsQuery
+            skip |= validate_reserved_flags(cmd_name, "pBeginInfo->pInheritanceInfo->pipelineStatistics", pInfo->pipelineStatistics,
+                                            "VUID-VkCommandBufferInheritanceInfo-pipelineStatistics-00058");
+        }
+
+        const auto *conditional_rendering = lvl_find_in_chain<VkCommandBufferInheritanceConditionalRenderingInfoEXT>(pInfo->pNext);
+        if (conditional_rendering) {
+            const auto *cr_features =
+                lvl_find_in_chain<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(physical_device_features2.pNext);
+            const auto inherited_conditional_rendering = cr_features && cr_features->inheritedConditionalRendering;
+            if (!inherited_conditional_rendering && conditional_rendering->conditionalRenderingEnable == VK_TRUE) {
+                skip |= log_msg(
+                    report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                    HandleToUint64(commandBuffer),
+                    "VUID-VkCommandBufferInheritanceConditionalRenderingInfoEXT-conditionalRenderingEnable-01977",
+                    "vkBeginCommandBuffer: Inherited conditional rendering is disabled, but "
+                    "pBeginInfo->pInheritanceInfo->pNext<VkCommandBufferInheritanceConditionalRenderingInfoEXT> is VK_TRUE.");
+            }
         }
     }
 
@@ -3004,55 +3273,161 @@ bool StatelessValidation::manual_PreCallValidateAllocateMemory(VkDevice device,
     return skip;
 }
 
-bool StatelessValidation::ValidateAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV &info) {
+bool StatelessValidation::ValidateGeometryTrianglesNV(const VkGeometryTrianglesNV &triangles,
+                                                      VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
+                                                      const char *func_name) const {
+    bool skip = false;
+
+    if (triangles.vertexFormat != VK_FORMAT_R32G32B32_SFLOAT && triangles.vertexFormat != VK_FORMAT_R16G16B16_SFLOAT &&
+        triangles.vertexFormat != VK_FORMAT_R16G16B16_SNORM && triangles.vertexFormat != VK_FORMAT_R32G32_SFLOAT &&
+        triangles.vertexFormat != VK_FORMAT_R16G16_SFLOAT && triangles.vertexFormat != VK_FORMAT_R16G16_SNORM) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryTrianglesNV-vertexFormat-02430", "%s", func_name);
+    } else {
+        uint32_t vertex_component_size = 0;
+        if (triangles.vertexFormat == VK_FORMAT_R32G32B32_SFLOAT || triangles.vertexFormat == VK_FORMAT_R32G32_SFLOAT) {
+            vertex_component_size = 4;
+        } else if (triangles.vertexFormat == VK_FORMAT_R16G16B16_SFLOAT || triangles.vertexFormat == VK_FORMAT_R16G16B16_SNORM ||
+                   triangles.vertexFormat == VK_FORMAT_R16G16_SFLOAT || triangles.vertexFormat == VK_FORMAT_R16G16_SNORM) {
+            vertex_component_size = 2;
+        }
+        if (vertex_component_size > 0 && SafeModulo(triangles.vertexOffset, vertex_component_size) != 0) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                            "VUID-VkGeometryTrianglesNV-vertexOffset-02429", "%s", func_name);
+        }
+    }
+
+    if (triangles.indexType != VK_INDEX_TYPE_UINT32 && triangles.indexType != VK_INDEX_TYPE_UINT16 &&
+        triangles.indexType != VK_INDEX_TYPE_NONE_NV) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryTrianglesNV-indexType-02433", "%s", func_name);
+    } else {
+        uint32_t index_element_size = 0;
+        if (triangles.indexType == VK_INDEX_TYPE_UINT32) {
+            index_element_size = 4;
+        } else if (triangles.indexType == VK_INDEX_TYPE_UINT16) {
+            index_element_size = 2;
+        }
+        if (index_element_size > 0 && SafeModulo(triangles.indexOffset, index_element_size) != 0) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                            "VUID-VkGeometryTrianglesNV-indexOffset-02432", "%s", func_name);
+        }
+    }
+    if (triangles.indexType == VK_INDEX_TYPE_NONE_NV) {
+        if (triangles.indexCount != 0) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                            "VUID-VkGeometryTrianglesNV-indexCount-02436", "%s", func_name);
+        }
+        if (triangles.indexData != VK_NULL_HANDLE) {
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                            "VUID-VkGeometryTrianglesNV-indexData-02434", "%s", func_name);
+        }
+    }
+
+    if (SafeModulo(triangles.transformOffset, 16) != 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryTrianglesNV-transformOffset-02438", "%s", func_name);
+    }
+
+    return skip;
+}
+
+bool StatelessValidation::ValidateGeometryAABBNV(const VkGeometryAABBNV &aabbs, VkDebugReportObjectTypeEXT object_type,
+                                                 uint64_t object_handle, const char *func_name) const {
+    bool skip = false;
+
+    if (SafeModulo(aabbs.offset, 8) != 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryAABBNV-offset-02440", "%s", func_name);
+    }
+    if (SafeModulo(aabbs.stride, 8) != 0) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                        "VUID-VkGeometryAABBNV-stride-02441", "%s", func_name);
+    }
+
+    return skip;
+}
+
+bool StatelessValidation::ValidateGeometryNV(const VkGeometryNV &geometry, VkDebugReportObjectTypeEXT object_type,
+                                             uint64_t object_handle, const char *func_name) const {
+    bool skip = false;
+    if (geometry.geometryType == VK_GEOMETRY_TYPE_TRIANGLES_NV) {
+        skip = ValidateGeometryTrianglesNV(geometry.geometry.triangles, object_type, object_handle, func_name);
+    } else if (geometry.geometryType == VK_GEOMETRY_TYPE_AABBS_NV) {
+        skip = ValidateGeometryAABBNV(geometry.geometry.aabbs, object_type, object_handle, func_name);
+    }
+    return skip;
+}
+
+bool StatelessValidation::ValidateAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV &info,
+                                                              VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
+                                                              const char *func_name) const {
     bool skip = false;
     if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV && info.geometryCount != 0) {
-        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, 0,
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
                         "VUID-VkAccelerationStructureInfoNV-type-02425",
                         "VkAccelerationStructureInfoNV: If type is VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV then "
                         "geometryCount must be 0.");
     }
     if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV && info.instanceCount != 0) {
-        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, 0,
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
                         "VUID-VkAccelerationStructureInfoNV-type-02426",
                         "VkAccelerationStructureInfoNV: If type is VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV then "
                         "instanceCount must be 0.");
     }
     if (info.flags & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV &&
         info.flags & VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV) {
-        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, 0,
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
                         "VUID-VkAccelerationStructureInfoNV-flags-02592",
                         "VkAccelerationStructureInfoNV: If flags has the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV"
                         "bit set, then it must not have the VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV bit set.");
     }
     if (info.geometryCount > phys_dev_ext_props.ray_tracing_props.maxGeometryCount) {
-        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, 0,
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
                         "VUID-VkAccelerationStructureInfoNV-geometryCount-02422",
                         "VkAccelerationStructureInfoNV: geometryCount must be less than or equal to "
                         "VkPhysicalDeviceRayTracingPropertiesNV::maxGeometryCount.");
     }
     if (info.instanceCount > phys_dev_ext_props.ray_tracing_props.maxInstanceCount) {
-        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, 0,
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
                         "VUID-VkAccelerationStructureInfoNV-instanceCount-02423",
                         "VkAccelerationStructureInfoNV: instanceCount must be less than or equal to "
                         "VkPhysicalDeviceRayTracingPropertiesNV::maxInstanceCount.");
     }
-    if (info.geometryCount > 0) {
+    if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV && info.geometryCount > 0) {
         uint64_t total_triangle_count = 0;
         for (uint32_t i = 0; i < info.geometryCount; i++) {
             const VkGeometryNV &geometry = info.pGeometries[i];
+
+            skip |= ValidateGeometryNV(geometry, object_type, object_handle, func_name);
+
             if (geometry.geometryType != VK_GEOMETRY_TYPE_TRIANGLES_NV) {
                 continue;
             }
             total_triangle_count += geometry.geometry.triangles.indexCount / 3;
         }
         if (total_triangle_count > phys_dev_ext_props.ray_tracing_props.maxTriangleCount) {
-            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
-                            0, "VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424",
+            skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle,
+                            "VUID-VkAccelerationStructureInfoNV-maxTriangleCount-02424",
                             "VkAccelerationStructureInfoNV: The total number of triangles in all geometries must be less than "
                             "or equal to VkPhysicalDeviceRayTracingPropertiesNV::maxTriangleCount.");
         }
     }
+    if (info.type == VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV && info.geometryCount > 1) {
+        const VkGeometryTypeNV first_geometry_type = info.pGeometries[0].geometryType;
+        for (uint32_t i = 1; i < info.geometryCount; i++) {
+            const VkGeometryNV &geometry = info.pGeometries[i];
+            if (geometry.geometryType != first_geometry_type) {
+                // TODO: update fake VUID below with the real one once it is generated.
+                skip |=
+                    log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+                            0, "UNASSIGNED-VkAccelerationStructureInfoNV-pGeometries-XXXX",
+                            "VkAccelerationStructureInfoNV: info.pGeometries[%d].geometryType does not match "
+                            "info.pGeometries[0].geometryType.",
+                            i);
+            }
+        }
+    }
     return skip;
 }
 
@@ -3071,7 +3446,8 @@ bool StatelessValidation::manual_PreCallValidateCreateAccelerationStructureNV(
                             pCreateInfo->compactedSize, pCreateInfo->info.geometryCount, pCreateInfo->info.instanceCount);
         }
 
-        skip |= ValidateAccelerationStructureInfoNV(pCreateInfo->info);
+        skip |= ValidateAccelerationStructureInfoNV(pCreateInfo->info, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT, 0,
+                                                    "vkCreateAccelerationStructureNV()");
     }
 
     return skip;
@@ -3083,7 +3459,8 @@ bool StatelessValidation::manual_PreCallValidateCmdBuildAccelerationStructureNV(
     bool skip = false;
 
     if (pInfo != nullptr) {
-        skip |= ValidateAccelerationStructureInfoNV(*pInfo);
+        skip |= ValidateAccelerationStructureInfoNV(*pInfo, VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT,
+                                                    HandleToUint64(dst), "vkCmdBuildAccelerationStructureNV()");
     }
 
     return skip;
@@ -3159,3 +3536,49 @@ bool StatelessValidation::PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(V
     return skip;
 }
 #endif
+
+bool StatelessValidation::manual_PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
+                                                                  const VkAllocationCallbacks *pAllocator,
+                                                                  VkFramebuffer *pFramebuffer) {
+    // Validation for pAttachments which is excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml
+    bool skip = false;
+    if ((pCreateInfo->flags & VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR) == 0) {
+        skip |= validate_array("vkCreateFramebuffer", "attachmentCount", "pAttachments", pCreateInfo->attachmentCount,
+                               &pCreateInfo->pAttachments, false, true, kVUIDUndefined, kVUIDUndefined);
+    }
+    return skip;
+}
+
+bool StatelessValidation::manual_PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                                     uint16_t lineStipplePattern) {
+    bool skip = false;
+
+    if (lineStippleFactor < 1 || lineStippleFactor > 256) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        HandleToUint64(commandBuffer), "VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776",
+                        "vkCmdSetLineStippleEXT::lineStippleFactor=%d is not in [1,256].", lineStippleFactor);
+    }
+
+    return skip;
+}
+
+bool StatelessValidation::manual_PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
+                                                                   VkDeviceSize offset, VkIndexType indexType) {
+    bool skip = false;
+
+    if (indexType == VK_INDEX_TYPE_NONE_NV) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        HandleToUint64(commandBuffer), "VUID-vkCmdBindIndexBuffer-indexType-02507",
+                        "vkCmdBindIndexBuffer() indexType must not be VK_INDEX_TYPE_NONE_NV.");
+    }
+
+    const auto *index_type_uint8_features =
+        lvl_find_in_chain<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(physical_device_features2.pNext);
+    if (indexType == VK_INDEX_TYPE_UINT8_EXT && !index_type_uint8_features->indexTypeUint8) {
+        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
+                        HandleToUint64(commandBuffer), "VUID-vkCmdBindIndexBuffer-indexType-02765",
+                        "vkCmdBindIndexBuffer() indexType is VK_INDEX_TYPE_UINT8_EXT but indexTypeUint8 feature is not enabled.");
+    }
+
+    return skip;
+}
diff --git a/layers/shader_validation.cpp b/layers/shader_validation.cpp
index b95928c1c..8f02a8de6 100644
--- a/layers/shader_validation.cpp
+++ b/layers/shader_validation.cpp
@@ -38,6 +38,50 @@
 #include "spirv-tools/libspirv.h"
 #include "xxhash.h"
 
+void decoration_set::add(uint32_t decoration, uint32_t value) {
+    switch (decoration) {
+        case spv::DecorationLocation:
+            flags |= location_bit;
+            location = value;
+            break;
+        case spv::DecorationPatch:
+            flags |= patch_bit;
+            break;
+        case spv::DecorationRelaxedPrecision:
+            flags |= relaxed_precision_bit;
+            break;
+        case spv::DecorationBlock:
+            flags |= block_bit;
+            break;
+        case spv::DecorationBufferBlock:
+            flags |= buffer_block_bit;
+            break;
+        case spv::DecorationComponent:
+            flags |= component_bit;
+            component = value;
+            break;
+        case spv::DecorationInputAttachmentIndex:
+            flags |= input_attachment_index_bit;
+            input_attachment_index = value;
+            break;
+        case spv::DecorationDescriptorSet:
+            flags |= descriptor_set_bit;
+            descriptor_set = value;
+            break;
+        case spv::DecorationBinding:
+            flags |= binding_bit;
+            binding = value;
+            break;
+        case spv::DecorationNonWritable:
+            flags |= nonwritable_bit;
+            break;
+        case spv::DecorationBuiltIn:
+            flags |= builtin_bit;
+            builtin = value;
+            break;
+    }
+}
+
 enum FORMAT_TYPE {
     FORMAT_TYPE_FLOAT = 1,  // UNORM, SNORM, FLOAT, USCALED, SSCALED, SRGB -- anything we consider float in the shader
     FORMAT_TYPE_SINT = 2,
@@ -122,6 +166,16 @@ void SHADER_MODULE_STATE::BuildDefIndex() {
                 def_index[insn.word(2)] = insn.offset();
                 break;
 
+                // Decorations
+            case spv::OpDecorate: {
+                auto targetId = insn.word(1);
+                decorations[targetId].add(insn.word(2), insn.len() > 3u ? insn.word(3) : 0u);
+            } break;
+            case spv::OpGroupDecorate: {
+                auto const &src = decorations[insn.word(1)];
+                for (auto i = 2u; i < insn.len(); i++) decorations[insn.word(i)].merge(src);
+            } break;
+
                 // Entry points ... add to the entrypoint table
             case spv::OpEntryPoint: {
                 // Entry points do not have an id (the id is the function id) and thus need their own table
@@ -131,6 +185,7 @@ void SHADER_MODULE_STATE::BuildDefIndex() {
                 entry_points.emplace(entrypoint_name, EntryPoint{insn.offset(), entrypoint_stage});
                 break;
             }
+
             default:
                 // We don't care about any other defs for now.
                 break;
@@ -548,11 +603,11 @@ static spirv_inst_iter GetStructType(SHADER_MODULE_STATE const *src, spirv_inst_
 }
 
 static bool CollectInterfaceBlockMembers(SHADER_MODULE_STATE const *src, std::map<location_t, interface_var> *out,
-                                         std::unordered_map<unsigned, unsigned> const &blocks, bool is_array_of_verts, uint32_t id,
-                                         uint32_t type_id, bool is_patch, int /*first_location*/) {
+                                         bool is_array_of_verts, uint32_t id, uint32_t type_id, bool is_patch,
+                                         int /*first_location*/) {
     // Walk down the type_id presented, trying to determine whether it's actually an interface block.
     auto type = GetStructType(src, src->get_def(type_id), is_array_of_verts && !is_patch);
-    if (type == src->end() || blocks.find(type.word(1)) == blocks.end()) {
+    if (type == src->end() || !(src->get_decorations(type.word(1)).flags & decoration_set::block_bit)) {
         // This isn't an interface block.
         return false;
     }
@@ -616,6 +671,8 @@ static bool CollectInterfaceBlockMembers(SHADER_MODULE_STATE const *src, std::ma
 }
 
 static std::vector<uint32_t> FindEntrypointInterfaces(spirv_inst_iter entrypoint) {
+    assert(entrypoint.opcode() == spv::OpEntryPoint);
+
     std::vector<uint32_t> interfaces;
     // 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.
@@ -632,66 +689,29 @@ static std::vector<uint32_t> FindEntrypointInterfaces(spirv_inst_iter entrypoint
 
 static std::map<location_t, interface_var> CollectInterfaceByLocation(SHADER_MODULE_STATE const *src, spirv_inst_iter entrypoint,
                                                                       spv::StorageClass sinterface, bool is_array_of_verts) {
-    std::unordered_map<unsigned, unsigned> var_locations;
-    std::unordered_map<unsigned, unsigned> var_builtins;
-    std::unordered_map<unsigned, unsigned> var_components;
-    std::unordered_map<unsigned, unsigned> blocks;
-    std::unordered_map<unsigned, unsigned> var_patch;
-    std::unordered_map<unsigned, unsigned> var_relaxed_precision;
-
-    for (auto insn : *src) {
-        // We consider two interface models: SSO rendezvous-by-location, and builtins. Complain about anything that
-        // fits neither model.
-        if (insn.opcode() == spv::OpDecorate) {
-            if (insn.word(2) == spv::DecorationLocation) {
-                var_locations[insn.word(1)] = insn.word(3);
-            }
-
-            if (insn.word(2) == spv::DecorationBuiltIn) {
-                var_builtins[insn.word(1)] = insn.word(3);
-            }
-
-            if (insn.word(2) == spv::DecorationComponent) {
-                var_components[insn.word(1)] = insn.word(3);
-            }
-
-            if (insn.word(2) == spv::DecorationBlock) {
-                blocks[insn.word(1)] = 1;
-            }
-
-            if (insn.word(2) == spv::DecorationPatch) {
-                var_patch[insn.word(1)] = 1;
-            }
-
-            if (insn.word(2) == spv::DecorationRelaxedPrecision) {
-                var_relaxed_precision[insn.word(1)] = 1;
-            }
-        }
-    }
-
-    // TODO: handle grouped decorations
     // TODO: handle index=1 dual source outputs from FS -- two vars will have the same location, and we DON'T want to clobber.
 
     std::map<location_t, interface_var> out;
 
-    for (uint32_t word : FindEntrypointInterfaces(entrypoint)) {
-        auto insn = src->get_def(word);
+    for (uint32_t iid : FindEntrypointInterfaces(entrypoint)) {
+        auto insn = src->get_def(iid);
         assert(insn != src->end());
         assert(insn.opcode() == spv::OpVariable);
 
         if (insn.word(3) == static_cast<uint32_t>(sinterface)) {
+            auto d = src->get_decorations(iid);
             unsigned id = insn.word(2);
             unsigned type = insn.word(1);
 
-            int location = ValueOrDefault(var_locations, id, static_cast<unsigned>(-1));
-            int builtin = ValueOrDefault(var_builtins, id, static_cast<unsigned>(-1));
-            unsigned component = ValueOrDefault(var_components, id, 0);  // Unspecified is OK, is 0
-            bool is_patch = var_patch.find(id) != var_patch.end();
-            bool is_relaxed_precision = var_relaxed_precision.find(id) != var_relaxed_precision.end();
+            int location = d.location;
+            int builtin = d.builtin;
+            unsigned component = d.component;
+            bool is_patch = (d.flags & decoration_set::patch_bit) != 0;
+            bool is_relaxed_precision = (d.flags & decoration_set::relaxed_precision_bit) != 0;
 
             if (builtin != -1)
                 continue;
-            else if (!CollectInterfaceBlockMembers(src, &out, blocks, is_array_of_verts, id, type, is_patch, location)) {
+            else if (!CollectInterfaceBlockMembers(src, &out, is_array_of_verts, id, type, is_patch, location)) {
                 // A user-defined interface variable, with a location. Where a variable occupied multiple locations, emit
                 // one result for each.
                 unsigned num_locations = GetLocationsConsumedByType(src, type, is_array_of_verts && !is_patch);
@@ -844,15 +864,10 @@ static bool IsWritableDescriptorType(SHADER_MODULE_STATE const *module, uint32_t
 
         case spv::OpTypeStruct: {
             std::unordered_set<unsigned> nonwritable_members;
+            if (module->get_decorations(type.word(1)).flags & decoration_set::buffer_block_bit) is_storage_buffer = true;
             for (auto insn : *module) {
-                if (insn.opcode() == spv::OpDecorate && insn.word(1) == type.word(1)) {
-                    if (insn.word(2) == spv::DecorationBufferBlock) {
-                        // Legacy storage block in the Uniform storage class
-                        // has its struct type decorated with BufferBlock.
-                        is_storage_buffer = true;
-                    }
-                } else if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1) &&
-                           insn.word(3) == spv::DecorationNonWritable) {
+                if (insn.opcode() == spv::OpMemberDecorate && insn.word(1) == type.word(1) &&
+                    insn.word(3) == spv::DecorationNonWritable) {
                     nonwritable_members.insert(insn.word(2));
                 }
             }
@@ -869,30 +884,6 @@ static bool IsWritableDescriptorType(SHADER_MODULE_STATE const *module, uint32_t
 static std::vector<std::pair<descriptor_slot_t, interface_var>> CollectInterfaceByDescriptorSlot(
     debug_report_data const *report_data, SHADER_MODULE_STATE const *src, std::unordered_set<uint32_t> const &accessible_ids,
     bool *has_writable_descriptor) {
-    std::unordered_map<unsigned, unsigned> var_sets;
-    std::unordered_map<unsigned, unsigned> var_bindings;
-    std::unordered_map<unsigned, unsigned> var_nonwritable;
-
-    for (auto insn : *src) {
-        // All variables in the Uniform or UniformConstant storage classes are required to be decorated with both
-        // DecorationDescriptorSet and DecorationBinding.
-        if (insn.opcode() == spv::OpDecorate) {
-            if (insn.word(2) == spv::DecorationDescriptorSet) {
-                var_sets[insn.word(1)] = insn.word(3);
-            }
-
-            if (insn.word(2) == spv::DecorationBinding) {
-                var_bindings[insn.word(1)] = insn.word(3);
-            }
-
-            // Note: do toplevel DecorationNonWritable out here; it applies to
-            // the OpVariable rather than the type.
-            if (insn.word(2) == spv::DecorationNonWritable) {
-                var_nonwritable[insn.word(1)] = 1;
-            }
-        }
-    }
-
     std::vector<std::pair<descriptor_slot_t, interface_var>> out;
 
     for (auto id : accessible_ids) {
@@ -902,15 +893,16 @@ static std::vector<std::pair<descriptor_slot_t, interface_var>> CollectInterface
         if (insn.opcode() == spv::OpVariable &&
             (insn.word(3) == spv::StorageClassUniform || insn.word(3) == spv::StorageClassUniformConstant ||
              insn.word(3) == spv::StorageClassStorageBuffer)) {
-            unsigned set = ValueOrDefault(var_sets, insn.word(2), 0);
-            unsigned binding = ValueOrDefault(var_bindings, insn.word(2), 0);
+            auto d = src->get_decorations(insn.word(2));
+            unsigned set = d.descriptor_set;
+            unsigned binding = d.binding;
 
             interface_var v = {};
             v.id = insn.word(2);
             v.type_id = insn.word(1);
             out.emplace_back(std::make_pair(set, binding), v);
 
-            if (var_nonwritable.find(id) == var_nonwritable.end() &&
+            if (!(d.flags & decoration_set::nonwritable_bit) &&
                 IsWritableDescriptorType(src, insn.word(1), insn.word(3) == spv::StorageClassStorageBuffer)) {
                 *has_writable_descriptor = true;
             }
@@ -1559,6 +1551,8 @@ bool CoreChecks::ValidateShaderCapabilities(SHADER_MODULE_STATE const *src, VkSh
             : IsEnabled([=](const DeviceFeatures &features) { return features.shader_image_footprint_features.*ptr; }) {}
         FeaturePointer(VkBool32 VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::*ptr)
             : IsEnabled([=](const DeviceFeatures &features) { return features.fragment_shader_interlock_features.*ptr; }) {}
+        FeaturePointer(VkBool32 VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::*ptr)
+            : IsEnabled([=](const DeviceFeatures &features) { return features.demote_to_helper_invocation_features.*ptr; }) {}
     };
 
     struct CapabilityInfo {
@@ -1670,6 +1664,7 @@ bool CoreChecks::ValidateShaderCapabilities(SHADER_MODULE_STATE const *src, VkSh
         {spv::CapabilityFragmentShaderSampleInterlockEXT,       {"VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderSampleInterlock",       &VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderSampleInterlock,         &DeviceExtensions::vk_ext_fragment_shader_interlock}},
         {spv::CapabilityFragmentShaderPixelInterlockEXT,        {"VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderPixelInterlock",        &VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderPixelInterlock,          &DeviceExtensions::vk_ext_fragment_shader_interlock}},
         {spv::CapabilityFragmentShaderShadingRateInterlockEXT,  {"VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderShadingRateInterlock",  &VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT::fragmentShaderShadingRateInterlock,    &DeviceExtensions::vk_ext_fragment_shader_interlock}},
+        {spv::CapabilityDemoteToHelperInvocationEXT,       {"VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::shaderDemoteToHelperInvocation",       &VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::shaderDemoteToHelperInvocation,         &DeviceExtensions::vk_ext_shader_demote_to_helper_invocation}},
     };
     // clang-format on
 
@@ -2353,12 +2348,32 @@ bool CoreChecks::ValidateExecutionModes(SHADER_MODULE_STATE const *src, spirv_in
                     if (first_denorm_execution_mode.first == spv::ExecutionModeMax) {
                         // Register the first denorm execution mode found
                         first_denorm_execution_mode = std::make_pair(static_cast<spv::ExecutionMode>(mode), bit_width);
-                    } else if (first_denorm_execution_mode.first != mode && first_denorm_execution_mode.second != bit_width &&
-                               !enabled_features.float_controls.separateDenormSettings) {
-                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                        kVUID_Core_Shader_FeatureNotEnabled,
-                                        "Shader uses separate denorm execution modes for different bit widths but "
-                                        "SeparateDenormSettings is not enabled on the device");
+                    } else if (first_denorm_execution_mode.first != mode && first_denorm_execution_mode.second != bit_width) {
+                        switch (enabled_features.float_controls.denormBehaviorIndependence) {
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR:
+                                if (first_rounding_mode.second != 32 && bit_width != 32) {
+                                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                                    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                    "Shader uses different denorm execution modes for 16 and 64-bit but "
+                                                    "denormBehaviorIndependence is "
+                                                    "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR on the device");
+                                }
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR:
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR:
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                "Shader uses different denorm execution modes for different bit widths but "
+                                                "denormBehaviorIndependence is "
+                                                "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR on the device");
+                                break;
+
+                            default:
+                                break;
+                        }
                     }
                     break;
                 }
@@ -2377,12 +2392,32 @@ bool CoreChecks::ValidateExecutionModes(SHADER_MODULE_STATE const *src, spirv_in
                     if (first_denorm_execution_mode.first == spv::ExecutionModeMax) {
                         // Register the first denorm execution mode found
                         first_denorm_execution_mode = std::make_pair(static_cast<spv::ExecutionMode>(mode), bit_width);
-                    } else if (first_denorm_execution_mode.first != mode && first_denorm_execution_mode.second != bit_width &&
-                               !enabled_features.float_controls.separateDenormSettings) {
-                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                        kVUID_Core_Shader_FeatureNotEnabled,
-                                        "Shader uses separate denorm execution modes for different bit widths but "
-                                        "SeparateDenormSettings is not enabled on the device");
+                    } else if (first_denorm_execution_mode.first != mode && first_denorm_execution_mode.second != bit_width) {
+                        switch (enabled_features.float_controls.denormBehaviorIndependence) {
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR:
+                                if (first_rounding_mode.second != 32 && bit_width != 32) {
+                                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                                    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                    "Shader uses different denorm execution modes for 16 and 64-bit but "
+                                                    "denormBehaviorIndependence is "
+                                                    "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR on the device");
+                                }
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR:
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR:
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                "Shader uses different denorm execution modes for different bit widths but "
+                                                "denormBehaviorIndependence is "
+                                                "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR on the device");
+                                break;
+
+                            default:
+                                break;
+                        }
                     }
                     break;
                 }
@@ -2401,12 +2436,32 @@ bool CoreChecks::ValidateExecutionModes(SHADER_MODULE_STATE const *src, spirv_in
                     if (first_rounding_mode.first == spv::ExecutionModeMax) {
                         // Register the first rounding mode found
                         first_rounding_mode = std::make_pair(static_cast<spv::ExecutionMode>(mode), bit_width);
-                    } else if (first_rounding_mode.first != mode && first_rounding_mode.second != bit_width &&
-                               !enabled_features.float_controls.separateRoundingModeSettings) {
-                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                        kVUID_Core_Shader_FeatureNotEnabled,
-                                        "Shader uses separate rounding modes for different bit widths but "
-                                        "SeparateRoundingModeSettings is not enabled on the device");
+                    } else if (first_rounding_mode.first != mode && first_rounding_mode.second != bit_width) {
+                        switch (enabled_features.float_controls.roundingModeIndependence) {
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR:
+                                if (first_rounding_mode.second != 32 && bit_width != 32) {
+                                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                                    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                    "Shader uses different rounding modes for 16 and 64-bit but "
+                                                    "roundingModeIndependence is "
+                                                    "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR on the device");
+                                }
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR:
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR:
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                "Shader uses different rounding modes for different bit widths but "
+                                                "roundingModeIndependence is "
+                                                "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR on the device");
+                                break;
+
+                            default:
+                                break;
+                        }
                     }
                     break;
                 }
@@ -2425,12 +2480,32 @@ bool CoreChecks::ValidateExecutionModes(SHADER_MODULE_STATE const *src, spirv_in
                     if (first_rounding_mode.first == spv::ExecutionModeMax) {
                         // Register the first rounding mode found
                         first_rounding_mode = std::make_pair(static_cast<spv::ExecutionMode>(mode), bit_width);
-                    } else if (first_rounding_mode.first != mode && first_rounding_mode.second != bit_width &&
-                               !enabled_features.float_controls.separateRoundingModeSettings) {
-                        skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                        kVUID_Core_Shader_FeatureNotEnabled,
-                                        "Shader uses separate rounding modes for different bit widths but "
-                                        "SeparateRoundingModeSettings is not enabled on the device");
+                    } else if (first_rounding_mode.first != mode && first_rounding_mode.second != bit_width) {
+                        switch (enabled_features.float_controls.roundingModeIndependence) {
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR:
+                                if (first_rounding_mode.second != 32 && bit_width != 32) {
+                                    skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                                    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                    "Shader uses different rounding modes for 16 and 64-bit but "
+                                                    "roundingModeIndependence is "
+                                                    "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR on the device");
+                                }
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR:
+                                break;
+
+                            case VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR:
+                                skip |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT,
+                                                0, kVUID_Core_Shader_FeatureNotEnabled,
+                                                "Shader uses different rounding modes for different bit widths but "
+                                                "roundingModeIndependence is "
+                                                "VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR on the device");
+                                break;
+
+                            default:
+                                break;
+                        }
                     }
                     break;
                 }
diff --git a/layers/shader_validation.h b/layers/shader_validation.h
index 8bf1b4427..0ecc6c794 100644
--- a/layers/shader_validation.h
+++ b/layers/shader_validation.h
@@ -71,12 +71,48 @@ struct spirv_inst_iter {
     spirv_inst_iter const &operator*() const { return *this; }
 };
 
+struct decoration_set {
+    enum {
+        location_bit = 1 << 0,
+        patch_bit = 1 << 1,
+        relaxed_precision_bit = 1 << 2,
+        block_bit = 1 << 3,
+        buffer_block_bit = 1 << 4,
+        component_bit = 1 << 5,
+        input_attachment_index_bit = 1 << 6,
+        descriptor_set_bit = 1 << 7,
+        binding_bit = 1 << 8,
+        nonwritable_bit = 1 << 9,
+        builtin_bit = 1 << 10,
+    };
+    uint32_t flags = 0;
+    uint32_t location = static_cast<uint32_t>(-1);
+    uint32_t component = 0;
+    uint32_t input_attachment_index = 0;
+    uint32_t descriptor_set = 0;
+    uint32_t binding = 0;
+    uint32_t builtin = static_cast<uint32_t>(-1);
+
+    void merge(decoration_set const &other) {
+        if (other.flags & location_bit) location = other.location;
+        if (other.flags & component_bit) component = other.component;
+        if (other.flags & input_attachment_index_bit) input_attachment_index = other.input_attachment_index;
+        if (other.flags & descriptor_set_bit) descriptor_set = other.descriptor_set;
+        if (other.flags & binding_bit) binding = other.binding;
+        if (other.flags & builtin_bit) builtin = other.builtin;
+        flags |= other.flags;
+    }
+
+    void add(uint32_t decoration, uint32_t value);
+};
+
 struct SHADER_MODULE_STATE {
     // The spirv image itself
     std::vector<uint32_t> words;
     // A mapping of <id> to the first word of its def. this is useful because walking type
     // trees, constant expressions, etc requires jumping all over the instruction stream.
     std::unordered_map<unsigned, unsigned> def_index;
+    std::unordered_map<unsigned, decoration_set> decorations;
     struct EntryPoint {
         uint32_t offset;
         VkShaderStageFlags stage;
@@ -143,6 +179,13 @@ struct SHADER_MODULE_STATE {
 
     SHADER_MODULE_STATE() : has_valid_spirv(false), vk_shader_module(VK_NULL_HANDLE) {}
 
+    decoration_set get_decorations(unsigned id) const {
+        // return the actual decorations for this id, or a default set.
+        auto it = decorations.find(id);
+        if (it != decorations.end()) return it->second;
+        return decoration_set();
+    }
+
     // Expose begin() / end() to enable range-based for
     spirv_inst_iter begin() const { return spirv_inst_iter(words.begin(), words.begin() + 5); }  // First insn
     spirv_inst_iter end() const { return spirv_inst_iter(words.begin(), words.end()); }          // Just past last insn
diff --git a/layers/stateless_validation.h b/layers/stateless_validation.h
index 7f0bd5784..199536ccc 100644
--- a/layers/stateless_validation.h
+++ b/layers/stateless_validation.h
@@ -21,8 +21,6 @@
 
 #pragma once
 
-#include <bitset>
-
 #include "parameter_name.h"
 #include "vk_typemap_helper.h"
 
@@ -44,6 +42,7 @@ static const char DECORATE_UNUSED *kVUID_PVError_DeviceLimit = "UNASSIGNED-Gener
 static const char DECORATE_UNUSED *kVUID_PVError_DeviceFeature = "UNASSIGNED-GeneralParameterError-DeviceFeature";
 static const char DECORATE_UNUSED *kVUID_PVError_FailureCode = "UNASSIGNED-GeneralParameterError-FailureCode";
 static const char DECORATE_UNUSED *kVUID_PVError_ExtensionNotEnabled = "UNASSIGNED-GeneralParameterError-ExtensionNotEnabled";
+static const char DECORATE_UNUSED *kVUID_PVPerfWarn_SuboptimalSwapchain = "UNASSIGNED-GeneralParameterPerfWarn-SuboptimalSwapchain";
 
 #undef DECORATE_UNUSED
 
@@ -54,6 +53,7 @@ extern const VkColorComponentFlags AllVkColorComponentFlagBits;
 extern const VkShaderStageFlags AllVkShaderStageFlagBits;
 extern const VkQueryControlFlags AllVkQueryControlFlagBits;
 extern const VkImageUsageFlags AllVkImageUsageFlagBits;
+extern const VkSampleCountFlags AllVkSampleCountFlagBits;
 
 extern const std::vector<VkCompareOp> AllVkCompareOpEnums;
 extern const std::vector<VkStencilOp> AllVkStencilOpEnums;
@@ -62,6 +62,9 @@ extern const std::vector<VkBlendOp> AllVkBlendOpEnums;
 extern const std::vector<VkLogicOp> AllVkLogicOpEnums;
 extern const std::vector<VkBorderColor> AllVkBorderColorEnums;
 extern const std::vector<VkImageLayout> AllVkImageLayoutEnums;
+extern const std::vector<VkFormat> AllVkFormatEnums;
+extern const std::vector<VkVertexInputRate> AllVkVertexInputRateEnums;
+extern const std::vector<VkPrimitiveTopology> AllVkPrimitiveTopologyEnums;
 
 // String returned by string_VkStructureType for an unrecognized type.
 const std::string UnsupportedStructureTypeString = "Unhandled VkStructureType";
@@ -87,7 +90,8 @@ struct LogMiscParams {
 class StatelessValidation : public ValidationObject {
    public:
     VkPhysicalDeviceLimits device_limits = {};
-    VkPhysicalDeviceFeatures physical_device_features = {};
+    safe_VkPhysicalDeviceFeatures2 physical_device_features2;
+    const VkPhysicalDeviceFeatures &physical_device_features = physical_device_features2.features;
 
     // Override chassis read/write locks for this validation object
     // This override takes a deferred lock. i.e. it is not acquired.
@@ -700,6 +704,8 @@ class StatelessValidation : public ValidationObject {
         return skip_call;
     }
 
+    enum FlagType { kRequiredFlags, kOptionalFlags, kRequiredSingleBit, kOptionalSingleBit };
+
     /**
      * Validate a Vulkan bitmask value.
      *
@@ -711,27 +717,37 @@ class StatelessValidation : public ValidationObject {
      * @param flag_bits_name Name of the VkFlags type being validated.
      * @param all_flags A bit mask combining all valid flag bits for the VkFlags type being validated.
      * @param value VkFlags value to validate.
-     * @param flags_required The 'value' parameter may not be 0 when true.
-     * @param singleFlag The 'value' parameter may not contain more than one bit from all_flags.
+     * @param flag_type The type of flag, like optional, or single bit.
+     * @param vuid VUID used for flag that is outside defined bits (or has more than one bit for Bits type).
+     * @param flags_zero_vuid VUID used for non-optional Flags that are zero.
      * @return Boolean value indicating that the call should be skipped.
      */
     bool validate_flags(const char *api_name, const ParameterName &parameter_name, const char *flag_bits_name, VkFlags all_flags,
-                        VkFlags value, bool flags_required, bool singleFlag, const char *vuid) {
+                        VkFlags value, const FlagType flag_type, const char *vuid, const char *flags_zero_vuid = nullptr) {
         bool skip_call = false;
 
-        if (value == 0) {
-            if (flags_required) {
-                skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
-                                     "%s: value of %s must not be 0.", api_name, parameter_name.get_name().c_str());
-            }
-        } else if ((value & (~all_flags)) != 0) {
-            skip_call |=
-                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                        kVUID_PVError_UnrecognizedValue, "%s: value of %s contains flag bits that are not recognized members of %s",
-                        api_name, parameter_name.get_name().c_str(), flag_bits_name);
-        } else if (singleFlag && (std::bitset<sizeof(VkFlags) * 8>(value).count() > 1)) {
-            skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
-                                 kVUID_PVError_UnrecognizedValue,
+        if ((value & ~all_flags) != 0) {
+            skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
+                                 "%s: value of %s contains flag bits that are not recognized members of %s", api_name,
+                                 parameter_name.get_name().c_str(), flag_bits_name);
+        }
+
+        const bool required = flag_type == kRequiredFlags || flag_type == kRequiredSingleBit;
+        const char *zero_vuid = flag_type == kRequiredFlags ? flags_zero_vuid : vuid;
+        if (required && value == 0) {
+            skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, zero_vuid,
+                                 "%s: value of %s must not be 0.", api_name, parameter_name.get_name().c_str());
+        }
+
+        const auto HasMaxOneBitSet = [](const VkFlags f) {
+            // Decrement flips bits from right upto first 1.
+            // Rest stays same, and if there was any other 1s &ded together they would be non-zero. QED
+            return f == 0 || !(f & (f - 1));
+        };
+
+        const bool is_bits_type = flag_type == kRequiredSingleBit || flag_type == kOptionalSingleBit;
+        if (is_bits_type && !HasMaxOneBitSet(value)) {
+            skip_call |= log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, vuid,
                                  "%s: value of %s contains multiple members of %s when only a single value is allowed", api_name,
                                  parameter_name.get_name().c_str(), flag_bits_name);
         }
@@ -821,6 +837,52 @@ class StatelessValidation : public ValidationObject {
     enum RenderPassCreateVersion { RENDER_PASS_VERSION_1 = 0, RENDER_PASS_VERSION_2 = 1 };
 
     template <typename RenderPassCreateInfoGeneric>
+    bool ValidateSubpassGraphicsFlags(const debug_report_data *report_data, const RenderPassCreateInfoGeneric *pCreateInfo,
+                                      uint32_t dependency_index, uint32_t subpass, VkPipelineStageFlags stages, const char *vuid,
+                                      const char *target) {
+        const VkPipelineStageFlags kCommonStages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+        const VkPipelineStageFlags kFramebufferStages =
+            VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+            VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
+        const VkPipelineStageFlags kPrimitiveShadingPipelineStages =
+            kCommonStages | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT | VK_PIPELINE_STAGE_VERTEX_INPUT_BIT |
+            VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT |
+            VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT |
+            VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT | VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV | kFramebufferStages;
+        const VkPipelineStageFlags kMeshShadingPipelineStages =
+            kCommonStages | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT | VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV |
+            VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV | VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV | kFramebufferStages;
+        const VkPipelineStageFlags kFragmentDensityStages = VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT;
+        const VkPipelineStageFlags kConditionalRenderingStages = VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT;
+        const VkPipelineStageFlags kCommandProcessingPipelineStages = kCommonStages | VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX;
+
+        const VkPipelineStageFlags kGraphicsStages = VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | kPrimitiveShadingPipelineStages |
+                                                     kMeshShadingPipelineStages | kFragmentDensityStages |
+                                                     kConditionalRenderingStages | kCommandProcessingPipelineStages;
+
+        bool skip = false;
+
+        const auto IsPipeline = [pCreateInfo](uint32_t subpass, const VkPipelineBindPoint stage) {
+            if (subpass == VK_SUBPASS_EXTERNAL)
+                return false;
+            else
+                return pCreateInfo->pSubpasses[subpass].pipelineBindPoint == stage;
+        };
+
+        const bool is_all_graphics_stages = (stages & ~kGraphicsStages) == 0;
+        if (IsPipeline(subpass, VK_PIPELINE_BIND_POINT_GRAPHICS) && !is_all_graphics_stages) {
+            skip |=
+                log_msg(report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT, 0, vuid,
+                        "Dependency pDependencies[%" PRIu32
+                        "] specifies a %sStageMask that contains stages (%s) that are not part "
+                        "of the Graphics pipeline, as specified by the %sSubpass (= %" PRIu32 ") in pipelineBindPoint.",
+                        dependency_index, target, string_VkPipelineStageFlags(stages & ~kGraphicsStages).c_str(), target, subpass);
+        }
+
+        return skip;
+    };
+
+    template <typename RenderPassCreateInfoGeneric>
     bool CreateRenderPassGeneric(VkDevice device, const RenderPassCreateInfoGeneric *pCreateInfo,
                                  const VkAllocationCallbacks *pAllocator, VkRenderPass *pRenderPass,
                                  RenderPassCreateVersion rp_version) {
@@ -859,6 +921,22 @@ class StatelessValidation : public ValidationObject {
                                 pCreateInfo->pSubpasses[i].colorAttachmentCount, max_color_attachments);
             }
         }
+
+        for (uint32_t i = 0; i < pCreateInfo->dependencyCount; ++i) {
+            const auto &dependency = pCreateInfo->pDependencies[i];
+
+            // Spec currently only supports Graphics pipeline in render pass -- so only that pipeline is currently checked
+            vuid =
+                use_rp2 ? "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054" : "VUID-VkRenderPassCreateInfo-pDependencies-00837";
+            skip |= ValidateSubpassGraphicsFlags(report_data, pCreateInfo, i, dependency.srcSubpass, dependency.srcStageMask, vuid,
+                                                 "src");
+
+            vuid =
+                use_rp2 ? "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055" : "VUID-VkRenderPassCreateInfo-pDependencies-00838";
+            skip |= ValidateSubpassGraphicsFlags(report_data, pCreateInfo, i, dependency.dstSubpass, dependency.dstStageMask, vuid,
+                                                 "dst");
+        }
+
         return skip;
     }
 
@@ -900,7 +978,14 @@ class StatelessValidation : public ValidationObject {
     bool ValidateDeviceQueueFamily(uint32_t queue_family, const char *cmd_name, const char *parameter_name,
                                    const std::string &error_code, bool optional);
 
-    bool ValidateAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV &info);
+    bool ValidateGeometryTrianglesNV(const VkGeometryTrianglesNV &triangles, VkDebugReportObjectTypeEXT object_type,
+                                     uint64_t object_handle, const char *func_name) const;
+    bool ValidateGeometryAABBNV(const VkGeometryAABBNV &geometry, VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
+                                const char *func_name) const;
+    bool ValidateGeometryNV(const VkGeometryNV &geometry, VkDebugReportObjectTypeEXT object_type, uint64_t object_handle,
+                            const char *func_name) const;
+    bool ValidateAccelerationStructureInfoNV(const VkAccelerationStructureInfoNV &info, VkDebugReportObjectTypeEXT object_type,
+                                             uint64_t object_handle, const char *func_nam) const;
 
     bool OutputExtensionError(const std::string &api_name, const std::string &extension_name);
 
@@ -915,6 +1000,8 @@ class StatelessValidation : public ValidationObject {
     void PostCallRecordCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator,
                                       VkInstance *pInstance, VkResult result);
 
+    void PostCallRecordQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo, VkResult result);
+
     bool manual_PreCallValidateCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
                                                const VkAllocationCallbacks *pAllocator, VkQueryPool *pQueryPool);
 
@@ -930,9 +1017,6 @@ class StatelessValidation : public ValidationObject {
     bool manual_PreCallValidateCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
                                            const VkAllocationCallbacks *pAllocator, VkImage *pImage);
 
-    bool manual_PreCallValidateCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
-                                               const VkAllocationCallbacks *pAllocator, VkImageView *pView);
-
     bool manual_PreCallValidateViewport(const VkViewport &viewport, const char *fn_name, const ParameterName &parameter_name,
                                         VkDebugReportObjectTypeEXT object_type, uint64_t object);
 
@@ -1069,5 +1153,15 @@ class StatelessValidation : public ValidationObject {
     bool PreCallValidateGetDeviceGroupSurfacePresentModes2EXT(VkDevice device, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo,
                                                               VkDeviceGroupPresentModeFlagsKHR *pModes);
 #endif  // VK_USE_PLATFORM_WIN32_KHR
+
+    bool manual_PreCallValidateCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
+                                                 const VkAllocationCallbacks *pAllocator, VkFramebuffer *pFramebuffer);
+
+    bool manual_PreCallValidateCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor,
+                                                    uint16_t lineStipplePattern);
+
+    bool manual_PreCallValidateCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset,
+                                                  VkIndexType indexType);
+
 #include "parameter_validation.h"
 };  // Class StatelessValidation
diff --git a/layers/vk_format_utils.cpp b/layers/vk_format_utils.cpp
index ab66a71b8..9990144b5 100644
--- a/layers/vk_format_utils.cpp
+++ b/layers/vk_format_utils.cpp
@@ -1213,6 +1213,14 @@ VK_LAYER_EXPORT VkDeviceSize SafeModulo(VkDeviceSize dividend, VkDeviceSize divi
     return result;
 }
 
+VK_LAYER_EXPORT VkDeviceSize SafeDivision(VkDeviceSize dividend, VkDeviceSize divisor) {
+    VkDeviceSize result = 0;
+    if (divisor != 0) {
+        result = dividend / divisor;
+    }
+    return result;
+}
+
 struct VULKAN_PER_PLANE_COMPATIBILITY {
     uint32_t width_divisor;
     uint32_t height_divisor;
diff --git a/layers/vk_format_utils.h b/layers/vk_format_utils.h
index 1dd04f8db..465605587 100644
--- a/layers/vk_format_utils.h
+++ b/layers/vk_format_utils.h
@@ -173,6 +173,7 @@ VK_LAYER_EXPORT uint32_t FormatElementSize(VkFormat format, VkImageAspectFlags a
 VK_LAYER_EXPORT double FormatTexelSize(VkFormat format);
 VK_LAYER_EXPORT VkFormatCompatibilityClass FormatCompatibilityClass(VkFormat format);
 VK_LAYER_EXPORT VkDeviceSize SafeModulo(VkDeviceSize dividend, VkDeviceSize divisor);
+VK_LAYER_EXPORT VkDeviceSize SafeDivision(VkDeviceSize dividend, VkDeviceSize divisor);
 VK_LAYER_EXPORT uint32_t GetPlaneIndex(VkImageAspectFlags aspect);
 VK_LAYER_EXPORT VkFormat FindMultiplaneCompatibleFormat(VkFormat fmt, VkImageAspectFlags plane_aspect);
 VK_LAYER_EXPORT VkExtent2D FindMultiplaneExtentDivisors(VkFormat mp_fmt, VkImageAspectFlags plane_aspect);
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index 42829fea1..d21e9ffa5 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -148,8 +148,8 @@ typedef struct _debug_report_data {
     bool g_DEBUG_UTILS{false};
     bool queueLabelHasInsert{false};
     bool cmdBufLabelHasInsert{false};
-    std::unordered_map<uint64_t, VkDebugMarkerObjectNameInfoEXT> debugObjectNameMap;
-    std::unordered_map<uint64_t, VkDebugUtilsObjectNameInfoEXT> debugUtilsObjectNameMap;
+    std::unordered_map<uint64_t, std::string> debugObjectNameMap;
+    std::unordered_map<uint64_t, std::string> debugUtilsObjectNameMap;
     std::unordered_map<VkQueue, std::unique_ptr<LoggingLabelState>> debugUtilsQueueLabels;
     std::unordered_map<VkCommandBuffer, std::unique_ptr<LoggingLabelState>> debugUtilsCmdBufLabels;
     // This mutex is defined as mutable since the normal usage for a debug report object is as 'const'. The mutable keyword allows
@@ -158,8 +158,8 @@ typedef struct _debug_report_data {
 
     void DebugReportSetUtilsObjectName(const VkDebugUtilsObjectNameInfoEXT *pNameInfo) {
         std::unique_lock<std::mutex> lock(debug_report_mutex);
-        if (pNameInfo) {
-            debugUtilsObjectNameMap[pNameInfo->objectHandle] = *pNameInfo;
+        if (pNameInfo->pObjectName) {
+            debugUtilsObjectNameMap[pNameInfo->objectHandle] = pNameInfo->pObjectName;
         } else {
             debugUtilsObjectNameMap.erase(pNameInfo->objectHandle);
         }
@@ -167,8 +167,8 @@ typedef struct _debug_report_data {
 
     void DebugReportSetMarkerObjectName(const VkDebugMarkerObjectNameInfoEXT *pNameInfo) {
         std::unique_lock<std::mutex> lock(debug_report_mutex);
-        if (pNameInfo) {
-            debugObjectNameMap[pNameInfo->object] = *pNameInfo;
+        if (pNameInfo->pObjectName) {
+            debugObjectNameMap[pNameInfo->object] = pNameInfo->pObjectName;
         } else {
             debugObjectNameMap.erase(pNameInfo->object);
         }
@@ -178,7 +178,7 @@ typedef struct _debug_report_data {
         std::string label = "";
         const auto utils_name_iter = debugUtilsObjectNameMap.find(object);
         if (utils_name_iter != debugUtilsObjectNameMap.end()) {
-            label = utils_name_iter->second.pObjectName;
+            label = utils_name_iter->second;
         }
         return label;
     }
@@ -187,7 +187,7 @@ typedef struct _debug_report_data {
         std::string label = "";
         const auto marker_name_iter = debugObjectNameMap.find(object);
         if (marker_name_iter != debugObjectNameMap.end()) {
-            label = marker_name_iter->second.pObjectName;
+            label = marker_name_iter->second;
         }
         return label;
     }
diff --git a/layers/vk_layer_utils.h b/layers/vk_layer_utils.h
index 723bc004a..b08d30de2 100644
--- a/layers/vk_layer_utils.h
+++ b/layers/vk_layer_utils.h
@@ -159,3 +159,161 @@ static inline int u_ffs(int val) {
 #ifdef __cplusplus
 }
 #endif
+
+// shared_mutex support added in MSVC 2015 update 2
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2
+#include <shared_mutex>
+#endif
+
+// Limited concurrent_unordered_map that supports internally-synchronized
+// insert/erase/access. Splits locking across N buckets and uses shared_mutex
+// for read/write locking. Iterators are not supported. The following
+// operations are supported:
+//
+// insert_or_assign: Insert a new element or update an existing element.
+// insert: Insert a new element and return whether it was inserted.
+// erase: Remove an element.
+// contains: Returns true if the key is in the map.
+// find: Returns != end() if found, value is in ret->second.
+// pop: Erases and returns the erased value if found.
+//
+// find/end: find returns a vaguely iterator-like type that can be compared to
+// end and can use iter->second to retrieve the reference. This is to ease porting
+// for existing code that combines the existence check and lookup in a single
+// operation (and thus a single lock). i.e.:
+//
+//      auto iter = map.find(key);
+//      if (iter != map.end()) {
+//          T t = iter->second;
+//          ...
+//
+// snapshot: Return an array of elements (key, value pairs) that satisfy an optional
+// predicate. This can be used as a substitute for iterators in exceptional cases.
+template <typename Key, typename T, int BUCKETSLOG2 = 2>
+class vl_concurrent_unordered_map {
+   public:
+    void insert_or_assign(const Key &key, const T &value) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        write_lock_guard_t lock(locks[h].lock);
+        maps[h][key] = value;
+    }
+
+    bool insert(const Key &key, const T &value) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        write_lock_guard_t lock(locks[h].lock);
+        auto ret = maps[h].insert(typename std::unordered_map<Key, T>::value_type(key, value));
+        return ret.second;
+    }
+
+    // returns size_type
+    size_t erase(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        write_lock_guard_t lock(locks[h].lock);
+        return maps[h].erase(key);
+    }
+
+    bool contains(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        read_lock_guard_t lock(locks[h].lock);
+        return maps[h].count(key) != 0;
+    }
+
+    // type returned by find() and end().
+    class FindResult {
+       public:
+        FindResult(bool a, T b) : result(a, std::move(b)) {}
+
+        // == and != only support comparing against end()
+        bool operator==(const FindResult &other) const {
+            if (result.first == false && other.result.first == false) {
+                return true;
+            }
+            return false;
+        }
+        bool operator!=(const FindResult &other) const { return !(*this == other); }
+
+        // Make -> act kind of like an iterator.
+        std::pair<bool, T> *operator->() { return &result; }
+        const std::pair<bool, T> *operator->() const { return &result; }
+
+       private:
+        // (found, reference to element)
+        std::pair<bool, T> result;
+    };
+
+    // find()/end() return a FindResult containing a copy of the value. For end(),
+    // return a default value.
+    FindResult end() { return FindResult(false, T()); }
+
+    FindResult find(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        read_lock_guard_t lock(locks[h].lock);
+
+        auto itr = maps[h].find(key);
+        bool found = itr != maps[h].end();
+
+        if (found) {
+            return FindResult(true, itr->second);
+        } else {
+            return end();
+        }
+    }
+
+    FindResult pop(const Key &key) {
+        uint32_t h = ConcurrentMapHashObject(key);
+        write_lock_guard_t lock(locks[h].lock);
+
+        auto itr = maps[h].find(key);
+        bool found = itr != maps[h].end();
+
+        if (found) {
+            auto ret = std::move(FindResult(true, itr->second));
+            maps[h].erase(itr);
+            return ret;
+        } else {
+            return end();
+        }
+    }
+
+    std::vector<std::pair<const Key, T>> snapshot(std::function<bool(T)> f = nullptr) {
+        std::vector<std::pair<const Key, T>> ret;
+        for (int h = 0; h < BUCKETS; ++h) {
+            read_lock_guard_t lock(locks[h].lock);
+            for (auto j : maps[h]) {
+                if (!f || f(j.second)) {
+                    ret.push_back(j);
+                }
+            }
+        }
+        return ret;
+    }
+
+   private:
+    static const int BUCKETS = (1 << BUCKETSLOG2);
+// shared_mutex support added in MSVC 2015 update 2
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2
+#include <shared_mutex>
+    typedef std::shared_mutex lock_t;
+    typedef std::shared_lock<lock_t> read_lock_guard_t;
+    typedef std::unique_lock<lock_t> write_lock_guard_t;
+#else
+    typedef std::mutex lock_t;
+    typedef std::unique_lock<lock_t> read_lock_guard_t;
+    typedef std::unique_lock<lock_t> write_lock_guard_t;
+#endif
+
+    std::unordered_map<Key, T> maps[BUCKETS];
+    struct {
+        lock_t lock;
+        // Put each lock on its own cache line to avoid false cache line sharing.
+        char padding[(-int(sizeof(lock_t))) & 63];
+    } locks[BUCKETS];
+
+    uint32_t ConcurrentMapHashObject(const Key &object) const {
+        uint64_t u64 = (uint64_t)(uintptr_t)object;
+        uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
+        hash ^= (hash >> BUCKETSLOG2) ^ (hash >> (2 * BUCKETSLOG2));
+        hash &= (BUCKETS - 1);
+        return hash;
+    }
+};
diff --git a/layers/vk_mem_alloc.h b/layers/vk_mem_alloc.h
index 629c2fb76..2c13549f0 100644
--- a/layers/vk_mem_alloc.h
+++ b/layers/vk_mem_alloc.h
@@ -30,6 +30,7 @@
 //    4/18/19 - Make changes to suppress warnings from clang
 //    6/05/19 - Make changes to suppress warnings from clang 3.8.0
 //    6/05/19 - Make changes to suppress more warnings from GCC
+//    8/09/19 - Make changes to suppress dead code warnings (from upstream master branch)
 //
 
 #ifndef AMD_VULKAN_MEMORY_ALLOCATOR_H
@@ -3136,7 +3137,7 @@ the containers.
 
 #ifndef VMA_USE_STL_SHARED_MUTEX
     // Minimum Visual Studio 2015 Update 2
-    #if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918
+    #if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2
         #define VMA_USE_STL_SHARED_MUTEX 1
     #endif
 #endif
@@ -3696,16 +3697,21 @@ static inline bool VmaIsBufferImageGranularityConflict(
 
 static void VmaWriteMagicValue(void* pData, VkDeviceSize offset)
 {
+#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
     uint32_t* pDst = (uint32_t*)((char*)pData + offset);
     const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
     for(size_t i = 0; i < numberCount; ++i, ++pDst)
     {
         *pDst = VMA_CORRUPTION_DETECTION_MAGIC_VALUE;
     }
+#else
+    // no-op
+#endif
 }
 
 static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
 {
+#if VMA_DEBUG_MARGIN > 0 && VMA_DEBUG_DETECT_CORRUPTION
     const uint32_t* pSrc = (const uint32_t*)((const char*)pData + offset);
     const size_t numberCount = VMA_DEBUG_MARGIN / sizeof(uint32_t);
     for(size_t i = 0; i < numberCount; ++i, ++pSrc)
@@ -3715,6 +3721,7 @@ static bool VmaValidateMagicValue(const void* pData, VkDeviceSize offset)
             return false;
         }
     }
+#endif
     return true;
 }
 
diff --git a/scripts/check_commit_message_format.sh b/scripts/check_commit_message_format.sh
index 8bc83830a..8b7c3ceab 100755
--- a/scripts/check_commit_message_format.sh
+++ b/scripts/check_commit_message_format.sh
@@ -30,6 +30,7 @@ NC='\033[0m' # No Color
 # Get user-supplied commit message text for applicable commits and insert
 # a unique separator string identifier. The git command returns ONLY the
 # subject line and body for each of the commits.
+TRAVIS_COMMIT_RANGE="${TRAVIS_COMMIT_RANGE/.../..}"
 COMMIT_TEXT=$(git log ${TRAVIS_COMMIT_RANGE} --pretty=format:"XXXNEWLINEXXX"%n%B)
 
 # Bail if there are none
@@ -55,17 +56,17 @@ printf %s "$COMMIT_TEXT" | while IFS='' read -r line; do
   fi
   chars=${#line}
   if [ $current_line -eq 1 ]; then
-    # Subject line should be 50 chars or less (but give some slack here)
-    if [ $chars -gt 54 ]; then
-      echo "The following subject line exceeds 50 characters in length."
+    # Subject line should be 64 chars or less
+    if [ $chars -gt 64 ]; then
+      echo "The following subject line exceeds 64 characters in length."
       echo "     '$line'"
       success=0
     fi
     i=$(($chars-1))
     last_char=${line:$i:1}
     # Output error if last char of subject line is not alpha-numeric
-    if [[ ! $last_char =~ [0-9a-zA-Z] ]]; then
-      echo "For the following commit, the last character of the subject line must not be non-alphanumeric."
+    if [[ $last_char =~ [.,] ]]; then
+      echo "For the following commit, the last character of the subject line must not be a period or comma."
       echo "     '$line'"
       success=0
     fi
diff --git a/scripts/external_revision_generator.py b/scripts/external_revision_generator.py
index 6edb9738e..497291ae1 100644
--- a/scripts/external_revision_generator.py
+++ b/scripts/external_revision_generator.py
@@ -24,6 +24,7 @@ import argparse
 import hashlib
 import subprocess
 import uuid
+import json
 
 def generate(symbol_name, commit_id, output_header_file):
     # Write commit ID to output header file
@@ -85,21 +86,36 @@ def get_commit_id_from_file(rev_file):
         return sha1.hexdigest()
 
 def get_commit_id_from_uuid():
-        unique_uuid = str(uuid.uuid4())
-        sha1 = hashlib.sha1();
-        sha1.update(unique_uuid.encode())
-        return sha1.hexdigest()
+    unique_uuid = str(uuid.uuid4())
+    sha1 = hashlib.sha1();
+    sha1.update(unique_uuid.encode())
+    return sha1.hexdigest()
+
+def get_commit_id_from_json(json_file, json_keys):
+    with open(json_file) as json_stream:
+        json_data = json.load(json_stream)
+    for key in json_keys.split(','):
+        if type(json_data) == list:
+            json_data = json_data[int(key)]
+        else:
+            json_data = json_data[key]
+    return json_data
 
 def main():
     parser = argparse.ArgumentParser()
-    parser.add_argument("-s", "--symbol_name", metavar="SYMBOL_NAME", required=True, help="C symbol name")
-    parser.add_argument("-o", "--output_header_file", metavar="OUTPUT_HEADER_FILE", required=True, help="output header file path")
     rev_method_group = parser.add_mutually_exclusive_group(required=True)
     rev_method_group.add_argument("--git_dir", metavar="SOURCE_DIR", help="git working copy directory")
     rev_method_group.add_argument("--rev_file", metavar="REVISION_FILE", help="source revision file path (must contain a SHA1 hash")
     rev_method_group.add_argument("--from_uuid", action='store_true', help="base SHA1 on a dynamically generated UUID")
+    rev_method_group.add_argument("--json_file", metavar="JSON_FILE", help="path to json file")
+    parser.add_argument("-s", "--symbol_name", metavar="SYMBOL_NAME", required=True, help="C symbol name")
+    parser.add_argument("-o", "--output_header_file", metavar="OUTPUT_HEADER_FILE", required=True, help="output header file path")
+    parser.add_argument("--json_keys", action='store', metavar="JSON_KEYS", help="comma-separated list of keys specifying SHA1 location in root json object for --json_file option")
     args = parser.parse_args()
 
+    if ('json_file' in args) != ('json_keys' in args):
+        parser.error('--json_file and --json_keys must be provided together')
+
     # We can either parse the latest Git commit ID out of the specified repository (preferred where possible),
     # or computing the SHA1 hash of the contents of a file passed on the command line and (where necessary --
     # e.g. when building the layers outside of a Git environment).
@@ -113,7 +129,9 @@ def main():
     elif args.rev_file is not None:
         # Read the commit ID from a file.
         commit_id = get_commit_id_from_file(args.rev_file)
-    elif args.from_uuid is not None:
+    elif args.json_file is not None:
+        commit_id = get_commit_id_from_json(args.json_file, args.json_keys)
+    elif args.from_uuid:
         commit_id = get_commit_id_from_uuid()
 
     if not is_sha1(commit_id):
diff --git a/scripts/generate_source.py b/scripts/generate_source.py
index 3c448adf3..db350c6e3 100755
--- a/scripts/generate_source.py
+++ b/scripts/generate_source.py
@@ -19,7 +19,6 @@
 # Author: Mike Schuchardt <mikes@lunarg.com>
 
 import argparse
-import common_codegen
 import filecmp
 import os
 import shutil
@@ -27,6 +26,8 @@ import subprocess
 import sys
 import tempfile
 
+import common_codegen
+
 # files to exclude from --verify check
 verify_exclude = ['.clang-format']
 
@@ -63,7 +64,8 @@ def main(argv):
                  os.path.abspath(os.path.join(args.registry, 'validusage.json')),
                  '-export_header'],
                 [common_codegen.repo_relative('scripts/external_revision_generator.py'),
-                 '--rev_file', common_codegen.repo_relative('scripts/known_good.json'),
+                 '--json_file', common_codegen.repo_relative('scripts/known_good.json'),
+                 '--json_keys', 'repos,0,commit',
                  '-s', 'SPIRV_TOOLS_COMMIT_ID',
                  '-o', 'spirv_tools_commit_id.h']]
 
@@ -83,10 +85,7 @@ def main(argv):
     for cmd in gen_cmds:
         print(' '.join(cmd))
         try:
-            subprocess.check_call([sys.executable] + cmd,
-                                  # ignore generator output, vk_validation_stats.py is especially noisy
-                                  stdout=subprocess.DEVNULL,
-                                  cwd=gen_dir)
+            subprocess.check_call([sys.executable] + cmd, cwd=gen_dir)
         except Exception as e:
             print('ERROR:', str(e))
             return 1
diff --git a/scripts/helper_file_generator.py b/scripts/helper_file_generator.py
index 42aeef366..e78d1b91c 100644
--- a/scripts/helper_file_generator.py
+++ b/scripts/helper_file_generator.py
@@ -88,6 +88,8 @@ class HelperFileOutputGenerator(OutputGenerator):
         self.core_object_types = []                       # Handy copy of core_object_type enum data
         self.device_extension_info = dict()               # Dict of device extension name defines and ifdef values
         self.instance_extension_info = dict()             # Dict of instance extension name defines and ifdef values
+        self.structextends_list = []                      # List of structs which extend another struct via pNext
+
 
         # Named tuples to store struct and command data
         self.StructType = namedtuple('StructType', ['name', 'value'])
@@ -203,13 +205,16 @@ class HelperFileOutputGenerator(OutputGenerator):
             if groupName == 'VkDebugReportObjectTypeEXT':
                 for elem in groupElem.findall('enum'):
                     if elem.get('supported') != 'disabled':
-                        item_name = elem.get('name')
-                        self.debug_report_object_types.append(item_name)
+                        if elem.get('alias') is None: # TODO: Strangely the "alias" fn parameter does not work
+                            item_name = elem.get('name')
+                            if self.debug_report_object_types.count(item_name) == 0: # TODO: Strangely there are duplicates
+                                self.debug_report_object_types.append(item_name)
             elif groupName == 'VkObjectType':
                 for elem in groupElem.findall('enum'):
                     if elem.get('supported') != 'disabled':
-                        item_name = elem.get('name')
-                        self.core_object_types.append(item_name)
+                        if elem.get('alias') is None: # TODO: Strangely the "alias" fn parameter does not work
+                            item_name = elem.get('name')
+                            self.core_object_types.append(item_name)
 
     #
     # Called for each type -- if the type is a struct/union, grab the metadata
@@ -348,6 +353,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     self.structTypes[typeName] = self.StructType(name=name, value=value)
             # Store pointer/array/string info
             isstaticarray = self.paramIsStaticArray(member)
+            structextends = False
             membersInfo.append(self.CommandParam(type=type,
                                                  name=name,
                                                  ispointer=self.paramIsPointer(member),
@@ -357,6 +363,9 @@ class HelperFileOutputGenerator(OutputGenerator):
                                                  len=self.getLen(member),
                                                  extstructs=self.registry.validextensionstructs[typeName] if name == 'pNext' else None,
                                                  cdecl=cdecl))
+        # If this struct extends another, keep its name in list for further processing
+        if typeinfo.elem.attrib.get('structextends') is not None:
+            self.structextends_list.append(typeName)
         self.structMembers.append(self.StructMemberData(name=typeName, members=membersInfo, ifdef_protect=self.featureExtraProtect))
     #
     # Enum_string_header: Create a routine to convert an enumerated value into a string
@@ -427,6 +436,7 @@ class HelperFileOutputGenerator(OutputGenerator):
             enum_string_helper_header += '#pragma warning( disable : 4065 )\n'
             enum_string_helper_header += '#endif\n'
             enum_string_helper_header += '\n'
+            enum_string_helper_header += '#include <string>\n'
             enum_string_helper_header += '#include <vulkan/vulkan.h>\n'
             enum_string_helper_header += '\n'
             enum_string_helper_header += self.enum_output
@@ -446,6 +456,10 @@ class HelperFileOutputGenerator(OutputGenerator):
         safe_struct_helper_header += '#pragma once\n'
         safe_struct_helper_header += '#include <vulkan/vulkan.h>\n'
         safe_struct_helper_header += '\n'
+        safe_struct_helper_header += 'void *SafePnextCopy(const void *pNext);\n'
+        safe_struct_helper_header += 'void FreePnextChain(const void *pNext);\n'
+        safe_struct_helper_header += 'char *SafeStringCopy(const char *in_string);\n'
+        safe_struct_helper_header += '\n'
         safe_struct_helper_header += self.GenerateSafeStructHeader()
         return safe_struct_helper_header
     #
@@ -727,24 +741,25 @@ class HelperFileOutputGenerator(OutputGenerator):
             object_types_header += '    "%s",\n' % item
         object_types_header += '};\n'
 
-        # Key creation helper for map comprehensions that convert between k<Name> and VK<Name> symbols
-        def to_key(regex, raw_key): return re.search(regex, raw_key).group(1).lower().replace("_","")
+        # Helpers to create unified dict key from k<Name>, VK_OBJECT_TYPE_<Name>, and VK_DEBUG_REPORT_OBJECT_TYPE_<Name>
+        def dro_to_key(raw_key): return re.search('^VK_DEBUG_REPORT_OBJECT_TYPE_(.*)_EXT$', raw_key).group(1).lower().replace("_","")
+        def vko_to_key(raw_key): return re.search('^VK_OBJECT_TYPE_(.*)', raw_key).group(1).lower().replace("_","")
+        def kenum_to_key(raw_key): return re.search('^kVulkanObjectType(.*)', raw_key).group(1).lower()
+
+        dro_dict = {dro_to_key(dro) : dro for dro in self.debug_report_object_types}
+        vko_dict = {vko_to_key(vko) : vko for vko in self.core_object_types}
 
         # Output a conversion routine from the layer object definitions to the debug report definitions
-        # As the VK_DEBUG_REPORT types are not being updated, specify UNKNOWN for unmatched types
         object_types_header += '\n'
         object_types_header += '// Helper array to get Vulkan VK_EXT_debug_report object type enum from the internal layers version\n'
         object_types_header += 'const VkDebugReportObjectTypeEXT get_debug_report_enum[] = {\n'
-        object_types_header += '    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeUnknown\n'
-
-        dbg_re = '^VK_DEBUG_REPORT_OBJECT_TYPE_(.*)_EXT$'
-        dbg_map = {to_key(dbg_re, dbg) : dbg for dbg in self.debug_report_object_types}
-        dbg_default = 'VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT'
+        object_types_header += '    VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, // kVulkanObjectTypeUnknown\n' # no unknown handle, so this must be here explicitly
 
         for object_type in type_list:
-            vk_object_type = dbg_map.get(object_type.replace("kVulkanObjectType", "").lower(), dbg_default)
-            object_types_header += '    %s,   // %s\n' % (vk_object_type, object_type)
-            object_type_info[object_type]['DbgType'] = vk_object_type
+            # VK_DEBUG_REPORT is not updated anymore; there might be missing object types
+            kenum_type = dro_dict.get(kenum_to_key(object_type), 'VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT')
+            object_types_header += '    %s,   // %s\n' % (kenum_type, object_type)
+            object_type_info[object_type]['DbgType'] = kenum_type
         object_types_header += '};\n'
 
         # Output a conversion routine from the layer object definitions to the core object type definitions
@@ -752,58 +767,38 @@ class HelperFileOutputGenerator(OutputGenerator):
         object_types_header += '\n'
         object_types_header += '// Helper array to get Official Vulkan VkObjectType enum from the internal layers version\n'
         object_types_header += 'const VkObjectType get_object_type_enum[] = {\n'
-        object_types_header += '    VK_OBJECT_TYPE_UNKNOWN, // kVulkanObjectTypeUnknown\n'
+        object_types_header += '    VK_OBJECT_TYPE_UNKNOWN, // kVulkanObjectTypeUnknown\n' # no unknown handle, so must be here explicitly
 
-        vko_re = '^VK_OBJECT_TYPE_(.*)'
-        vko_map = {to_key(vko_re, vko) : vko for vko in self.core_object_types}
         for object_type in type_list:
-            vk_object_type = vko_map[object_type.replace("kVulkanObjectType", "").lower()]
-            object_types_header += '    %s,   // %s\n' % (vk_object_type, object_type)
-            object_type_info[object_type]['VkoType'] = vk_object_type
+            kenum_type = vko_dict[kenum_to_key(object_type)]
+            object_types_header += '    %s,   // %s\n' % (kenum_type, object_type)
+            object_type_info[object_type]['VkoType'] = kenum_type
         object_types_header += '};\n'
 
-        # Create a function to convert from VkDebugReportObjectTypeEXT to VkObjectType
-        object_types_header += '\n'
-        object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n'
-        object_types_header += 'static inline VkObjectType convertDebugReportObjectToCoreObject(VkDebugReportObjectTypeEXT debug_report_obj){\n'
-        object_types_header += '    if (debug_report_obj == VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT) {\n'
-        object_types_header += '        return VK_OBJECT_TYPE_UNKNOWN;\n'
-        for core_object_type in self.core_object_types:
-            core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower()
-            core_target_type = core_target_type.replace("_", "")
-            for dr_object_type in self.debug_report_object_types:
-                dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower()
-                dr_target_type = dr_target_type[:-4]
-                dr_target_type = dr_target_type.replace("_", "")
-                if core_target_type == dr_target_type:
-                    object_types_header += '    } else if (debug_report_obj == %s) {\n' % dr_object_type
-                    object_types_header += '        return %s;\n' % core_object_type
-                    break
-        object_types_header += '    }\n'
-        object_types_header += '    return VK_OBJECT_TYPE_UNKNOWN;\n'
-        object_types_header += '}\n'
-
-        # Create a function to convert from VkObjectType to VkDebugReportObjectTypeEXT
-        object_types_header += '\n'
-        object_types_header += '// Helper function to convert from VkDebugReportObjectTypeEXT to VkObjectType\n'
-        object_types_header += 'static inline VkDebugReportObjectTypeEXT convertCoreObjectToDebugReportObject(VkObjectType core_report_obj){\n'
-        object_types_header += '    if (core_report_obj == VK_OBJECT_TYPE_UNKNOWN) {\n'
-        object_types_header += '        return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n'
+        # Create a functions to convert between VkDebugReportObjectTypeEXT and VkObjectType
+        object_types_header +=     '\n'
+        object_types_header +=     'static inline VkObjectType convertDebugReportObjectToCoreObject(VkDebugReportObjectTypeEXT debug_report_obj) {\n'
+        object_types_header +=     '    switch (debug_report_obj) {\n'
+        for dr_object_type in self.debug_report_object_types:
+            object_types_header += '        case %s: return %s;\n' % (dr_object_type, vko_dict[dro_to_key(dr_object_type)])
+        object_types_header +=     '        default: return VK_OBJECT_TYPE_UNKNOWN;\n'
+        object_types_header +=     '    }\n'
+        object_types_header +=     '}\n'
+
+        object_types_header +=         '\n'
+        object_types_header +=         'static inline VkDebugReportObjectTypeEXT convertCoreObjectToDebugReportObject(VkObjectType core_report_obj) {\n'
+        object_types_header +=         '    switch (core_report_obj) {\n'
         for core_object_type in self.core_object_types:
-            core_target_type = core_object_type.replace("VK_OBJECT_TYPE_", "").lower()
-            core_target_type = core_target_type.replace("_", "")
-            for dr_object_type in self.debug_report_object_types:
-                dr_target_type = dr_object_type.replace("VK_DEBUG_REPORT_OBJECT_TYPE_", "").lower()
-                dr_target_type = dr_target_type[:-4]
-                dr_target_type = dr_target_type.replace("_", "")
-                if core_target_type == dr_target_type:
-                    object_types_header += '    } else if (core_report_obj == %s) {\n' % core_object_type
-                    object_types_header += '        return %s;\n' % dr_object_type
-                    break
-        object_types_header += '    }\n'
-        object_types_header += '    return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n'
-        object_types_header += '}\n'
+            # VK_DEBUG_REPORT is not updated anymore; there might be missing object types
+            dr_object_type = dro_dict.get(vko_to_key(core_object_type))
+            if dr_object_type is not None:
+                object_types_header += '        case %s: return %s;\n' % (core_object_type, dr_object_type)
+        object_types_header +=         '        default: return VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT;\n'
+        object_types_header +=         '    }\n'
+        object_types_header +=         '}\n'
 
+        #
+        object_types_header += '\n'
         traits_format = Outdent('''
             template <> struct VkHandleInfo<{vk_type}> {{
                 static const VulkanObjectType kVulkanObjectType = {obj_type};
@@ -875,9 +870,107 @@ class HelperFileOutputGenerator(OutputGenerator):
 
         return object_types_header
     #
+    # Generate pNext handling function
+    def build_safe_struct_utility_funcs(self):
+        # Construct Safe-struct helper functions
+
+        string_copy_proc = '\n\n'
+        string_copy_proc += 'char *SafeStringCopy(const char *in_string) {\n'
+        string_copy_proc += '    if (nullptr == in_string) return nullptr;\n'
+        string_copy_proc += '    char* dest = new char[std::strlen(in_string) + 1];\n'
+        string_copy_proc += '    return std::strcpy(dest, in_string);\n'
+        string_copy_proc += '}\n'
+
+        build_pnext_proc = '\n'
+        build_pnext_proc += 'void *SafePnextCopy(const void *pNext) {\n'
+        build_pnext_proc += '    if (!pNext) return nullptr;\n'
+        build_pnext_proc += '\n'
+        build_pnext_proc += '    void *safe_pNext;\n'
+        build_pnext_proc += '    const VkBaseOutStructure *header = reinterpret_cast<const VkBaseOutStructure *>(pNext);\n'
+        build_pnext_proc += '\n'
+        build_pnext_proc += '    switch (header->sType) {\n'
+        # Add special-case code to copy beloved secret loader structs
+        build_pnext_proc += '        // Special-case Loader Instance Struct passed to/from layer in pNext chain\n'
+        build_pnext_proc += '        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: {\n'
+        build_pnext_proc += '            VkLayerInstanceCreateInfo *struct_copy = new VkLayerInstanceCreateInfo;\n'
+        build_pnext_proc += '            // TODO: Uses original VkLayerInstanceLink* chain, which should be okay for our uses\n'
+        build_pnext_proc += '            memcpy(struct_copy, pNext, sizeof(VkLayerInstanceCreateInfo));\n'
+        build_pnext_proc += '            struct_copy->pNext = SafePnextCopy(header->pNext);\n'
+        build_pnext_proc += '            safe_pNext = struct_copy;\n'
+        build_pnext_proc += '            break;\n'
+        build_pnext_proc += '        }\n'
+        build_pnext_proc += '        // Special-case Loader Device Struct passed to/from layer in pNext chain\n'
+        build_pnext_proc += '        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: {\n'
+        build_pnext_proc += '            VkLayerDeviceCreateInfo *struct_copy = new VkLayerDeviceCreateInfo;\n'
+        build_pnext_proc += '            // TODO: Uses original VkLayerDeviceLink*, which should be okay for our uses\n'
+        build_pnext_proc += '            memcpy(struct_copy, pNext, sizeof(VkLayerDeviceCreateInfo));\n'
+        build_pnext_proc += '            struct_copy->pNext = SafePnextCopy(header->pNext);\n'
+        build_pnext_proc += '            safe_pNext = struct_copy;\n'
+        build_pnext_proc += '            break;\n'
+        build_pnext_proc += '        }\n'
+
+        free_pnext_proc = '\n'
+        free_pnext_proc += 'void FreePnextChain(const void *pNext) {\n'
+        free_pnext_proc += '    if (!pNext) return;\n'
+        free_pnext_proc += '\n'
+        free_pnext_proc += '    auto header = reinterpret_cast<const VkBaseOutStructure *>(pNext);\n'
+        free_pnext_proc += '\n'
+        free_pnext_proc += '    switch (header->sType) {\n'
+        free_pnext_proc += '        // Special-case Loader Instance Struct passed to/from layer in pNext chain\n'
+        free_pnext_proc += '        case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:\n'
+        free_pnext_proc += '            FreePnextChain(header->pNext);\n'
+        free_pnext_proc += '            delete reinterpret_cast<const VkLayerInstanceCreateInfo *>(pNext);\n'
+        free_pnext_proc += '            break;\n'
+        free_pnext_proc += '        // Special-case Loader Device Struct passed to/from layer in pNext chain\n'
+        free_pnext_proc += '        case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:\n'
+        free_pnext_proc += '            FreePnextChain(header->pNext);\n'
+        free_pnext_proc += '            delete reinterpret_cast<const VkLayerDeviceCreateInfo *>(pNext);\n'
+        free_pnext_proc += '            break;\n'
+
+        chain_structs = tuple(s for s in self.structMembers if s.name in self.structextends_list)
+        ifdefs = sorted({cs.ifdef_protect for cs in chain_structs}, key = lambda i : i if i is not None else '')
+        for ifdef in ifdefs:
+            if ifdef is not None:
+                build_pnext_proc += '#ifdef %s\n' % ifdef
+                free_pnext_proc += '#ifdef %s\n' % ifdef
+
+            assorted_chain_structs = tuple(s for s in chain_structs if s.ifdef_protect == ifdef)
+            for struct in assorted_chain_structs:
+                build_pnext_proc += '        case %s:\n' % self.structTypes[struct.name].value
+                build_pnext_proc += '            safe_pNext = new safe_%s(reinterpret_cast<const %s *>(pNext));\n' % (struct.name, struct.name)
+                build_pnext_proc += '            break;\n'
+
+                free_pnext_proc += '        case %s:\n' % self.structTypes[struct.name].value
+                free_pnext_proc += '            delete reinterpret_cast<const safe_%s *>(header);\n' % struct.name
+                free_pnext_proc += '            break;\n'
+
+            if ifdef is not None:
+                build_pnext_proc += '#endif // %s\n' % ifdef
+                free_pnext_proc += '#endif // %s\n' % ifdef
+
+        build_pnext_proc += '        default: // Encountered an unknown sType -- skip (do not copy) this entry in the chain\n'
+        build_pnext_proc += '            safe_pNext = SafePnextCopy(header->pNext);\n'
+        build_pnext_proc += '            break;\n'
+        build_pnext_proc += '    }\n'
+        build_pnext_proc += '\n'
+        build_pnext_proc += '    return safe_pNext;\n'
+        build_pnext_proc += '}\n'
+
+        free_pnext_proc += '        default: // Encountered an unknown sType -- panic, there should be none such in safe chain\n'
+        free_pnext_proc += '            assert(false);\n'
+        free_pnext_proc += '            FreePnextChain(header->pNext);\n'
+        free_pnext_proc += '            break;\n'
+        free_pnext_proc += '    }\n'
+        free_pnext_proc += '}\n'
+
+        pnext_procs = string_copy_proc + build_pnext_proc + free_pnext_proc
+        return pnext_procs
+    #
     # Determine if a structure needs a safe_struct helper function
     # That is, it has an sType or one of its members is a pointer
     def NeedSafeStruct(self, structure):
+        if 'VkBase' in structure.name:
+            return False
         if 'sType' == structure.name:
             return True
         for member in structure.members:
@@ -889,9 +982,16 @@ class HelperFileOutputGenerator(OutputGenerator):
     def GenerateSafeStructHelperSource(self):
         safe_struct_helper_source = '\n'
         safe_struct_helper_source += '#include "vk_safe_struct.h"\n'
+        safe_struct_helper_source += '\n'
         safe_struct_helper_source += '#include <string.h>\n'
+        safe_struct_helper_source += '#include <cassert>\n'
+        safe_struct_helper_source += '#include <cstring>\n'
+        safe_struct_helper_source += '\n'
+        safe_struct_helper_source += '#include <vulkan/vk_layer.h>\n'
         safe_struct_helper_source += '\n'
         safe_struct_helper_source += self.GenerateSafeStructSource()
+        safe_struct_helper_source += self.build_safe_struct_utility_funcs()
+
         return safe_struct_helper_source
     #
     # safe_struct source -- create bodies of safe struct helper functions
@@ -934,7 +1034,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     '        case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:\n'
                     '        if (descriptorCount && in_struct->pImageInfo) {\n'
                     '            pImageInfo = new VkDescriptorImageInfo[descriptorCount];\n'
-                    '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
+                    '            for (uint32_t i = 0; i < descriptorCount; ++i) {\n'
                     '                pImageInfo[i] = in_struct->pImageInfo[i];\n'
                     '            }\n'
                     '        }\n'
@@ -945,7 +1045,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     '        case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:\n'
                     '        if (descriptorCount && in_struct->pBufferInfo) {\n'
                     '            pBufferInfo = new VkDescriptorBufferInfo[descriptorCount];\n'
-                    '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
+                    '            for (uint32_t i = 0; i < descriptorCount; ++i) {\n'
                     '                pBufferInfo[i] = in_struct->pBufferInfo[i];\n'
                     '            }\n'
                     '        }\n'
@@ -954,7 +1054,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     '        case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:\n'
                     '        if (descriptorCount && in_struct->pTexelBufferView) {\n'
                     '            pTexelBufferView = new VkBufferView[descriptorCount];\n'
-                    '            for (uint32_t i=0; i<descriptorCount; ++i) {\n'
+                    '            for (uint32_t i = 0; i < descriptorCount; ++i) {\n'
                     '                pTexelBufferView[i] = in_struct->pTexelBufferView[i];\n'
                     '            }\n'
                     '        }\n'
@@ -971,7 +1071,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                 'VkGraphicsPipelineCreateInfo' :
                     '    if (stageCount && in_struct->pStages) {\n'
                     '        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
-                    '        for (uint32_t i=0; i<stageCount; ++i) {\n'
+                    '        for (uint32_t i = 0; i < stageCount; ++i) {\n'
                     '            pStages[i].initialize(&in_struct->pStages[i]);\n'
                     '        }\n'
                     '    }\n'
@@ -985,7 +1085,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     '        pInputAssemblyState = NULL;\n'
                     '    bool has_tessellation_stage = false;\n'
                     '    if (stageCount && pStages)\n'
-                    '        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
+                    '        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)\n'
                     '            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
                     '                has_tessellation_stage = true;\n'
                     '    if (in_struct->pTessellationState && has_tessellation_stage)\n'
@@ -1048,7 +1148,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     '    const bool sampler_type = in_struct->descriptorType == VK_DESCRIPTOR_TYPE_SAMPLER || in_struct->descriptorType == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;\n'
                     '    if (descriptorCount && in_struct->pImmutableSamplers && sampler_type) {\n'
                     '        pImmutableSamplers = new VkSampler[descriptorCount];\n'
-                    '        for (uint32_t i=0; i<descriptorCount; ++i) {\n'
+                    '        for (uint32_t i = 0; i < descriptorCount; ++i) {\n'
                     '            pImmutableSamplers[i] = in_struct->pImmutableSamplers[i];\n'
                     '        }\n'
                     '    }\n',
@@ -1057,9 +1157,10 @@ class HelperFileOutputGenerator(OutputGenerator):
             custom_copy_txt = {
                 # VkGraphicsPipelineCreateInfo is special case because it has custom construct parameters
                 'VkGraphicsPipelineCreateInfo' :
+                    '    pNext = SafePnextCopy(src.pNext);\n'
                     '    if (stageCount && src.pStages) {\n'
                     '        pStages = new safe_VkPipelineShaderStageCreateInfo[stageCount];\n'
-                    '        for (uint32_t i=0; i<stageCount; ++i) {\n'
+                    '        for (uint32_t i = 0; i < stageCount; ++i) {\n'
                     '            pStages[i].initialize(&src.pStages[i]);\n'
                     '        }\n'
                     '    }\n'
@@ -1073,7 +1174,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     '        pInputAssemblyState = NULL;\n'
                     '    bool has_tessellation_stage = false;\n'
                     '    if (stageCount && pStages)\n'
-                    '        for (uint32_t i=0; i<stageCount && !has_tessellation_stage; ++i)\n'
+                    '        for (uint32_t i = 0; i < stageCount && !has_tessellation_stage; ++i)\n'
                     '            if (pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT || pStages[i].stage == VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT)\n'
                     '                has_tessellation_stage = true;\n'
                     '    if (src.pTessellationState && has_tessellation_stage)\n'
@@ -1107,6 +1208,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                     '        pDynamicState = NULL;\n',
                  # VkPipelineViewportStateCreateInfo is special case because it has custom construct parameters
                 'VkPipelineViewportStateCreateInfo' :
+                    '    pNext = SafePnextCopy(src.pNext);\n'
                     '    if (src.pViewports) {\n'
                     '        pViewports = new VkViewport[src.viewportCount];\n'
                     '        memcpy ((void *)pViewports, (void *)src.pViewports, sizeof(VkViewport)*src.viewportCount);\n'
@@ -1124,9 +1226,12 @@ class HelperFileOutputGenerator(OutputGenerator):
             custom_destruct_txt = {'VkShaderModuleCreateInfo' :
                                    '    if (pCode)\n'
                                    '        delete[] reinterpret_cast<const uint8_t *>(pCode);\n' }
-
+            copy_pnext = ''
+            copy_strings = ''
             for member in item.members:
                 m_type = member.type
+                if member.name == 'pNext':
+                    copy_pnext = '    pNext = SafePnextCopy(in_struct->pNext);\n'
                 if member.type in self.structNames:
                     member_index = next((i for i, v in enumerate(self.structMembers) if v[0] == member.type), None)
                     if member_index is not None and self.NeedSafeStruct(self.structMembers[member_index]) == True:
@@ -1134,9 +1239,30 @@ class HelperFileOutputGenerator(OutputGenerator):
                 if member.ispointer and 'safe_' not in m_type and self.TypeContainsObjectHandle(member.type, False) == False:
                     # Ptr types w/o a safe_struct, for non-null case need to allocate new ptr and copy data in
                     if m_type in ['void', 'char']:
-                        # For these exceptions just copy initial value over for now
-                        init_list += '\n    %s(in_struct->%s),' % (member.name, member.name)
-                        init_func_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
+                        if member.name != 'pNext':
+                            if m_type == 'char':
+                                # Create deep copies of strings
+                                if member.len:
+                                    copy_strings += '    char **tmp_%s = new char *[in_struct->%s];\n' % (member.name, member.len)
+                                    copy_strings += '    for (uint32_t i = 0; i < %s; ++i) {\n' % member.len
+                                    copy_strings += '        tmp_%s[i] = SafeStringCopy(in_struct->%s[i]);\n' % (member.name, member.name)
+                                    copy_strings += '    }\n'
+                                    copy_strings += '    %s = tmp_%s;\n' % (member.name, member.name)
+
+                                    destruct_txt += '    if (%s) {\n' % member.name
+                                    destruct_txt += '        for (uint32_t i = 0; i < %s; ++i) {\n' % member.len
+                                    destruct_txt += '            delete [] %s[i];\n' % member.name
+                                    destruct_txt += '        }\n'
+                                    destruct_txt += '        delete [] %s;\n' % member.name
+                                    destruct_txt += '    }\n'
+                                else:
+                                    copy_strings += '    %s = SafeStringCopy(in_struct->%s);\n' % (member.name, member.name)
+                                    destruct_txt += '    if (%s) delete [] %s;\n' % (member.name, member.name)
+                            else:
+                                # For these exceptions just copy initial value over for now
+                                init_list += '\n    %s(in_struct->%s),' % (member.name, member.name)
+                                init_func_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
+                        default_init_list += '\n    %s(nullptr),' % (member.name)
                     else:
                         default_init_list += '\n    %s(nullptr),' % (member.name)
                         init_list += '\n    %s(nullptr),' % (member.name)
@@ -1144,25 +1270,24 @@ class HelperFileOutputGenerator(OutputGenerator):
                             construct_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
                         else:
                             init_func_txt += '    %s = nullptr;\n' % (member.name)
-                            if 'pNext' != member.name and 'void' not in m_type:
-                                if not member.isstaticarray and (member.len is None or '/' in member.len):
-                                    construct_txt += '    if (in_struct->%s) {\n' % member.name
-                                    construct_txt += '        %s = new %s(*in_struct->%s);\n' % (member.name, m_type, member.name)
-                                    construct_txt += '    }\n'
-                                    destruct_txt += '    if (%s)\n' % member.name
-                                    destruct_txt += '        delete %s;\n' % member.name
-                                else:
-                                    construct_txt += '    if (in_struct->%s) {\n' % member.name
-                                    construct_txt += '        %s = new %s[in_struct->%s];\n' % (member.name, m_type, member.len)
-                                    construct_txt += '        memcpy ((void *)%s, (void *)in_struct->%s, sizeof(%s)*in_struct->%s);\n' % (member.name, member.name, m_type, member.len)
-                                    construct_txt += '    }\n'
-                                    destruct_txt += '    if (%s)\n' % member.name
-                                    destruct_txt += '        delete[] %s;\n' % member.name
+                            if not member.isstaticarray and (member.len is None or '/' in member.len):
+                                construct_txt += '    if (in_struct->%s) {\n' % member.name
+                                construct_txt += '        %s = new %s(*in_struct->%s);\n' % (member.name, m_type, member.name)
+                                construct_txt += '    }\n'
+                                destruct_txt += '    if (%s)\n' % member.name
+                                destruct_txt += '        delete %s;\n' % member.name
+                            else:
+                                construct_txt += '    if (in_struct->%s) {\n' % member.name
+                                construct_txt += '        %s = new %s[in_struct->%s];\n' % (member.name, m_type, member.len)
+                                construct_txt += '        memcpy ((void *)%s, (void *)in_struct->%s, sizeof(%s)*in_struct->%s);\n' % (member.name, member.name, m_type, member.len)
+                                construct_txt += '    }\n'
+                                destruct_txt += '    if (%s)\n' % member.name
+                                destruct_txt += '        delete[] %s;\n' % member.name
                 elif member.isstaticarray or member.len is not None:
                     if member.len is None:
                         # Extract length of static array by grabbing val between []
                         static_array_size = re.match(r"[^[]*\[([^]]*)\]", member.cdecl)
-                        construct_txt += '    for (uint32_t i=0; i<%s; ++i) {\n' % static_array_size.group(1)
+                        construct_txt += '    for (uint32_t i = 0; i < %s; ++i) {\n' % static_array_size.group(1)
                         construct_txt += '        %s[i] = in_struct->%s[i];\n' % (member.name, member.name)
                         construct_txt += '    }\n'
                     else:
@@ -1179,7 +1304,7 @@ class HelperFileOutputGenerator(OutputGenerator):
                         construct_txt += '        %s = new %s[%s];\n' % (member.name, m_type, member.len)
                         destruct_txt += '    if (%s)\n' % member.name
                         destruct_txt += '        delete[] %s;\n' % member.name
-                        construct_txt += '        for (uint32_t i=0; i<%s; ++i) {\n' % (member.len)
+                        construct_txt += '        for (uint32_t i = 0; i < %s; ++i) {\n' % (member.len)
                         if 'safe_' in m_type:
                             construct_txt += '            %s[i].initialize(&in_struct->%s[i]);\n' % (member.name, member.name)
                         else:
@@ -1187,10 +1312,11 @@ class HelperFileOutputGenerator(OutputGenerator):
                         construct_txt += '        }\n'
                         construct_txt += '    }\n'
                 elif member.ispointer == True:
+                    default_init_list += '\n    %s(nullptr),' % (member.name)
+                    init_list += '\n    %s(nullptr),' % (member.name)
+                    init_func_txt += '    %s = nullptr;\n' % (member.name)
                     construct_txt += '    if (in_struct->%s)\n' % member.name
                     construct_txt += '        %s = new %s(in_struct->%s);\n' % (member.name, m_type, member.name)
-                    construct_txt += '    else\n'
-                    construct_txt += '        %s = NULL;\n' % member.name
                     destruct_txt += '    if (%s)\n' % member.name
                     destruct_txt += '        delete %s;\n' % member.name
                 elif 'safe_' in m_type:
@@ -1201,19 +1327,29 @@ class HelperFileOutputGenerator(OutputGenerator):
                     init_func_txt += '    %s = in_struct->%s;\n' % (member.name, member.name)
             if '' != init_list:
                 init_list = init_list[:-1] # hack off final comma
+
+
             if item.name in custom_construct_txt:
                 construct_txt = custom_construct_txt[item.name]
+
+            construct_txt = copy_pnext + copy_strings + construct_txt
+
             if item.name in custom_destruct_txt:
                 destruct_txt = custom_destruct_txt[item.name]
+
+            if copy_pnext:
+                destruct_txt += '    if (pNext)\n        FreePnextChain(pNext);\n'
+
             safe_struct_body.append("\n%s::%s(const %s* in_struct%s) :%s\n{\n%s}" % (ss_name, ss_name, item.name, self.custom_construct_params.get(item.name, ''), init_list, construct_txt))
             if '' != default_init_list:
                 default_init_list = " :%s" % (default_init_list[:-1])
             safe_struct_body.append("\n%s::%s()%s\n{}" % (ss_name, ss_name, default_init_list))
             # Create slight variation of init and construct txt for copy constructor that takes a src object reference vs. struct ptr
             copy_construct_init = init_func_txt.replace('in_struct->', 'src.')
-            copy_construct_txt = construct_txt.replace(' (in_struct->', ' (src.')     # Exclude 'if' blocks from next line
-            copy_construct_txt = copy_construct_txt.replace('(in_struct->', '(*src.') # Pass object to copy constructors
-            copy_construct_txt = copy_construct_txt.replace('in_struct->', 'src.')    # Modify remaining struct refs for src object
+            copy_construct_txt = construct_txt.replace(' (in_struct->', ' (src.')            # Exclude 'if' blocks from next line
+            copy_construct_txt = construct_txt.replace(' (in_struct->', ' (src.')               # Exclude 'if' blocks from next line
+            copy_construct_txt = re.sub('(new \\w+)\\(in_struct->', '\\1(*src.', construct_txt) # Pass object to copy constructors
+            copy_construct_txt = copy_construct_txt.replace('in_struct->', 'src.')              # Modify remaining struct refs for src object
             if item.name in custom_copy_txt:
                 copy_construct_txt = custom_copy_txt[item.name]
             copy_assign_txt = '    if (&src == this) return *this;\n\n' + destruct_txt + '\n' + copy_construct_init + copy_construct_txt + '\n    return *this;'
diff --git a/scripts/known_good.json b/scripts/known_good.json
index b9b519ecf..311d18028 100644
--- a/scripts/known_good.json
+++ b/scripts/known_good.json
@@ -6,7 +6,7 @@
       "sub_dir" : "glslang",
       "build_dir" : "glslang/build",
       "install_dir" : "glslang/build/install",
-      "commit" : "21eebe74214488264bbf0d19323a03c13a9e53a7",
+      "commit" : "333d1c95792692205472c457d7bec915a94c8000",
       "prebuild" : [
         "python update_glslang_sources.py"
       ],
@@ -20,7 +20,7 @@
       "sub_dir" : "Vulkan-Headers",
       "build_dir" : "Vulkan-Headers/build",
       "install_dir" : "Vulkan-Headers/build/install",
-      "commit" : "v1.1.114"
+      "commit" : "v1.1.121"
     },
     {
       "name" : "Vulkan-Loader",
@@ -28,7 +28,7 @@
       "sub_dir" : "Vulkan-Loader",
       "build_dir" : "Vulkan-Loader/build",
       "install_dir" : "Vulkan-Loader/build/install",
-      "commit" : "v1.1.114",
+      "commit" : "v1.1.121",
       "deps" : [
         {
           "var_name" : "VULKAN_HEADERS_INSTALL_DIR",
@@ -37,6 +37,10 @@
       ],
       "cmake_options" : [
         "-DBUILD_TESTS=NO"
+      ],
+      "build_platforms" : [
+        "linux",
+        "darwin"
       ]
     },
     {
@@ -45,7 +49,7 @@
       "sub_dir" : "VulkanTools",
       "build_dir" : "VulkanTools/build",
       "install_dir" : "VulkanTools/build/install",
-      "commit" : "bf8f554683401b820f2d8e3ef1a41fe8e0acf4ce",
+      "commit" : "206108f07f531cab5523ff36d7947f39cdd7ad6b",
       "deps" : [
         {
           "var_name" : "VULKAN_HEADERS_INSTALL_DIR",
@@ -83,7 +87,7 @@
       "sub_dir" : "Vulkan-Tools",
       "build_dir" : "Vulkan-Tools/build",
       "install_dir" : "Vulkan-Tools/build/install",
-      "commit" : "v1.1.114",
+      "commit" : "e36c760bbde1c56b5b2a934347ff0fb9dce4d793",
       "deps" : [
         {
           "var_name" : "VULKAN_HEADERS_INSTALL_DIR",
diff --git a/scripts/layer_chassis_dispatch_generator.py b/scripts/layer_chassis_dispatch_generator.py
index 897c00592..3088bcd22 100644
--- a/scripts/layer_chassis_dispatch_generator.py
+++ b/scripts/layer_chassis_dispatch_generator.py
@@ -148,7 +148,6 @@ VkResult DispatchCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
                                                                                           pCreateInfos, pAllocator, pPipelines);
     safe_VkComputePipelineCreateInfo *local_pCreateInfos = NULL;
     if (pCreateInfos) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_pCreateInfos = new safe_VkComputePipelineCreateInfo[createInfoCount];
         for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
             local_pCreateInfos[idx0].initialize(&pCreateInfos[idx0]);
@@ -164,7 +163,6 @@ VkResult DispatchCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
         }
     }
     if (pipelineCache) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipelineCache = layer_data->Unwrap(pipelineCache);
     }
 
@@ -172,7 +170,6 @@ VkResult DispatchCreateComputePipelines(VkDevice device, VkPipelineCache pipelin
                                                                                local_pCreateInfos->ptr(), pAllocator, pPipelines);
     delete[] local_pCreateInfos;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < createInfoCount; ++i) {
             if (pPipelines[i] != VK_NULL_HANDLE) {
                 pPipelines[i] = layer_data->WrapNew(pPipelines[i]);
@@ -191,7 +188,7 @@ VkResult DispatchCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
     safe_VkGraphicsPipelineCreateInfo *local_pCreateInfos = nullptr;
     if (pCreateInfos) {
         local_pCreateInfos = new safe_VkGraphicsPipelineCreateInfo[createInfoCount];
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
             bool uses_color_attachment = false;
             bool uses_depthstencil_attachment = false;
@@ -227,7 +224,6 @@ VkResult DispatchCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
         }
     }
     if (pipelineCache) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         pipelineCache = layer_data->Unwrap(pipelineCache);
     }
 
@@ -235,7 +231,6 @@ VkResult DispatchCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeli
                                                                                 local_pCreateInfos->ptr(), pAllocator, pPipelines);
     delete[] local_pCreateInfos;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < createInfoCount; ++i) {
             if (pPipelines[i] != VK_NULL_HANDLE) {
                 pPipelines[i] = layer_data->WrapNew(pPipelines[i]);
@@ -270,7 +265,7 @@ VkResult DispatchCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo
     VkResult result = layer_data->device_dispatch_table.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
     if (!wrap_handles) return result;
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         UpdateCreateRenderPassState(layer_data, pCreateInfo, *pRenderPass);
         *pRenderPass = layer_data->WrapNew(*pRenderPass);
     }
@@ -283,7 +278,7 @@ VkResult DispatchCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateI
     VkResult result = layer_data->device_dispatch_table.CreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass);
     if (!wrap_handles) return result;
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         UpdateCreateRenderPassState(layer_data, pCreateInfo, *pRenderPass);
         *pRenderPass = layer_data->WrapNew(*pRenderPass);
     }
@@ -293,14 +288,18 @@ VkResult DispatchCreateRenderPass2KHR(VkDevice device, const VkRenderPassCreateI
 void DispatchDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks *pAllocator) {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
     uint64_t renderPass_id = reinterpret_cast<uint64_t &>(renderPass);
-    renderPass = (VkRenderPass)unique_id_mapping[renderPass_id];
-    unique_id_mapping.erase(renderPass_id);
-    lock.unlock();
+
+    auto iter = unique_id_mapping.pop(renderPass_id);
+    if (iter != unique_id_mapping.end()) {
+        renderPass = (VkRenderPass)iter->second;
+    } else {
+        renderPass = (VkRenderPass)0;
+    }
+
     layer_data->device_dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
 
-    lock.lock();
+    write_dispatch_lock_guard_t lock(dispatch_lock);
     layer_data->renderpasses_states.erase(renderPass);
 }
 
@@ -310,7 +309,6 @@ VkResult DispatchCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfo
     if (!wrap_handles) return layer_data->device_dispatch_table.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
     safe_VkSwapchainCreateInfoKHR *local_pCreateInfo = NULL;
     if (pCreateInfo) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_pCreateInfo = new safe_VkSwapchainCreateInfoKHR(pCreateInfo);
         local_pCreateInfo->oldSwapchain = layer_data->Unwrap(pCreateInfo->oldSwapchain);
         // Surface is instance-level object
@@ -321,7 +319,6 @@ VkResult DispatchCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfo
     delete local_pCreateInfo;
 
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         *pSwapchain = layer_data->WrapNew(*pSwapchain);
     }
     return result;
@@ -335,7 +332,6 @@ VkResult DispatchCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCo
                                                                            pSwapchains);
     safe_VkSwapchainCreateInfoKHR *local_pCreateInfos = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfos) {
             local_pCreateInfos = new safe_VkSwapchainCreateInfoKHR[swapchainCount];
             for (uint32_t i = 0; i < swapchainCount; ++i) {
@@ -354,7 +350,6 @@ VkResult DispatchCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCo
                                                                                   pAllocator, pSwapchains);
     delete[] local_pCreateInfos;
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < swapchainCount; i++) {
             pSwapchains[i] = layer_data->WrapNew(pSwapchains[i]);
         }
@@ -369,14 +364,13 @@ VkResult DispatchGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain
         return layer_data->device_dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
     VkSwapchainKHR wrapped_swapchain_handle = swapchain;
     if (VK_NULL_HANDLE != swapchain) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         swapchain = layer_data->Unwrap(swapchain);
     }
     VkResult result =
         layer_data->device_dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
     if ((VK_SUCCESS == result) || (VK_INCOMPLETE == result)) {
         if ((*pSwapchainImageCount > 0) && pSwapchainImages) {
-            std::lock_guard<std::mutex> lock(dispatch_lock);
+            write_dispatch_lock_guard_t lock(dispatch_lock);
             auto &wrapped_swapchain_image_handles = layer_data->swapchain_wrapped_image_handle_map[wrapped_swapchain_handle];
             for (uint32_t i = static_cast<uint32_t>(wrapped_swapchain_image_handles.size()); i < *pSwapchainImageCount; i++) {
                 wrapped_swapchain_image_handles.emplace_back(layer_data->WrapNew(pSwapchainImages[i]));
@@ -392,18 +386,24 @@ VkResult DispatchGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain
 void DispatchDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks *pAllocator) {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
 
     auto &image_array = layer_data->swapchain_wrapped_image_handle_map[swapchain];
     for (auto &image_handle : image_array) {
         unique_id_mapping.erase(HandleToUint64(image_handle));
     }
     layer_data->swapchain_wrapped_image_handle_map.erase(swapchain);
+    lock.unlock();
 
     uint64_t swapchain_id = HandleToUint64(swapchain);
-    swapchain = (VkSwapchainKHR)unique_id_mapping[swapchain_id];
-    unique_id_mapping.erase(swapchain_id);
-    lock.unlock();
+
+    auto iter = unique_id_mapping.pop(swapchain_id);
+    if (iter != unique_id_mapping.end()) {
+        swapchain = (VkSwapchainKHR)iter->second;
+    } else {
+        swapchain = (VkSwapchainKHR)0;
+    }
+
     layer_data->device_dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
 }
 
@@ -412,7 +412,6 @@ VkResult DispatchQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresent
     if (!wrap_handles) return layer_data->device_dispatch_table.QueuePresentKHR(queue, pPresentInfo);
     safe_VkPresentInfoKHR *local_pPresentInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pPresentInfo) {
             local_pPresentInfo = new safe_VkPresentInfoKHR(pPresentInfo);
             if (local_pPresentInfo->pWaitSemaphores) {
@@ -443,18 +442,24 @@ VkResult DispatchQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresent
 void DispatchDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks *pAllocator) {
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles) return layer_data->device_dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
 
     // remove references to implicitly freed descriptor sets
     for(auto descriptor_set : layer_data->pool_descriptor_sets_map[descriptorPool]) {
         unique_id_mapping.erase(reinterpret_cast<uint64_t &>(descriptor_set));
     }
     layer_data->pool_descriptor_sets_map.erase(descriptorPool);
+    lock.unlock();
 
     uint64_t descriptorPool_id = reinterpret_cast<uint64_t &>(descriptorPool);
-    descriptorPool = (VkDescriptorPool)unique_id_mapping[descriptorPool_id];
-    unique_id_mapping.erase(descriptorPool_id);
-    lock.unlock();
+
+    auto iter = unique_id_mapping.pop(descriptorPool_id);
+    if (iter != unique_id_mapping.end()) {
+        descriptorPool = (VkDescriptorPool)iter->second;
+    } else {
+        descriptorPool = (VkDescriptorPool)0;
+    }
+
     layer_data->device_dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator);
 }
 
@@ -463,12 +468,11 @@ VkResult DispatchResetDescriptorPool(VkDevice device, VkDescriptorPool descripto
     if (!wrap_handles) return layer_data->device_dispatch_table.ResetDescriptorPool(device, descriptorPool, flags);
     VkDescriptorPool local_descriptor_pool = VK_NULL_HANDLE;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_descriptor_pool = layer_data->Unwrap(descriptorPool);
     }
     VkResult result = layer_data->device_dispatch_table.ResetDescriptorPool(device, local_descriptor_pool, flags);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         // remove references to implicitly freed descriptor sets
         for(auto descriptor_set : layer_data->pool_descriptor_sets_map[descriptorPool]) {
             unique_id_mapping.erase(reinterpret_cast<uint64_t &>(descriptor_set));
@@ -485,7 +489,6 @@ VkResult DispatchAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAl
     if (!wrap_handles) return layer_data->device_dispatch_table.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
     safe_VkDescriptorSetAllocateInfo *local_pAllocateInfo = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pAllocateInfo) {
             local_pAllocateInfo = new safe_VkDescriptorSetAllocateInfo(pAllocateInfo);
             if (pAllocateInfo->descriptorPool) {
@@ -504,7 +507,7 @@ VkResult DispatchAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAl
         delete local_pAllocateInfo;
     }
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         auto &pool_descriptor_sets = layer_data->pool_descriptor_sets_map[pAllocateInfo->descriptorPool];
         for (uint32_t index0 = 0; index0 < pAllocateInfo->descriptorSetCount; index0++) {
             pDescriptorSets[index0] = layer_data->WrapNew(pDescriptorSets[index0]);
@@ -522,7 +525,6 @@ VkResult DispatchFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptor
     VkDescriptorSet *local_pDescriptorSets = NULL;
     VkDescriptorPool local_descriptor_pool = VK_NULL_HANDLE;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         local_descriptor_pool = layer_data->Unwrap(descriptorPool);
         if (pDescriptorSets) {
             local_pDescriptorSets = new VkDescriptorSet[descriptorSetCount];
@@ -535,7 +537,7 @@ VkResult DispatchFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptor
                                                                            (const VkDescriptorSet *)local_pDescriptorSets);
     if (local_pDescriptorSets) delete[] local_pDescriptorSets;
     if ((VK_SUCCESS == result) && (pDescriptorSets)) {
-        std::unique_lock<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         auto &pool_descriptor_sets = layer_data->pool_descriptor_sets_map[descriptorPool];
         for (uint32_t index0 = 0; index0 < descriptorSetCount; index0++) {
             VkDescriptorSet handle = pDescriptorSets[index0];
@@ -557,7 +559,6 @@ VkResult DispatchCreateDescriptorUpdateTemplate(VkDevice device, const VkDescrip
                                                                                 pDescriptorUpdateTemplate);
     safe_VkDescriptorUpdateTemplateCreateInfo *local_create_info = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo);
             if (pCreateInfo->descriptorSetLayout) {
@@ -571,7 +572,7 @@ VkResult DispatchCreateDescriptorUpdateTemplate(VkDevice device, const VkDescrip
     VkResult result = layer_data->device_dispatch_table.CreateDescriptorUpdateTemplate(device, local_create_info->ptr(), pAllocator,
                                                                                        pDescriptorUpdateTemplate);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         *pDescriptorUpdateTemplate = layer_data->WrapNew(*pDescriptorUpdateTemplate);
 
         // Shadow template createInfo for later updates
@@ -591,7 +592,6 @@ VkResult DispatchCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDesc
                                                                                    pDescriptorUpdateTemplate);
     safe_VkDescriptorUpdateTemplateCreateInfo *local_create_info = NULL;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         if (pCreateInfo) {
             local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo);
             if (pCreateInfo->descriptorSetLayout) {
@@ -605,7 +605,7 @@ VkResult DispatchCreateDescriptorUpdateTemplateKHR(VkDevice device, const VkDesc
     VkResult result = layer_data->device_dispatch_table.CreateDescriptorUpdateTemplateKHR(device, local_create_info->ptr(), pAllocator,
                                                                                           pDescriptorUpdateTemplate);
     if (VK_SUCCESS == result) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        write_dispatch_lock_guard_t lock(dispatch_lock);
         *pDescriptorUpdateTemplate = layer_data->WrapNew(*pDescriptorUpdateTemplate);
 
         // Shadow template createInfo for later updates
@@ -621,12 +621,18 @@ void DispatchDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdate
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles)
         return layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
     uint64_t descriptor_update_template_id = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     layer_data->desc_template_createinfo_map.erase(descriptor_update_template_id);
-    descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[descriptor_update_template_id];
-    unique_id_mapping.erase(descriptor_update_template_id);
     lock.unlock();
+
+    auto iter = unique_id_mapping.pop(descriptor_update_template_id);
+    if (iter != unique_id_mapping.end()) {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)iter->second;
+    } else {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)0;
+    }
+
     layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
 }
 
@@ -636,12 +642,18 @@ void DispatchDestroyDescriptorUpdateTemplateKHR(VkDevice device, VkDescriptorUpd
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     if (!wrap_handles)
         return layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
-    std::unique_lock<std::mutex> lock(dispatch_lock);
+    write_dispatch_lock_guard_t lock(dispatch_lock);
     uint64_t descriptor_update_template_id = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     layer_data->desc_template_createinfo_map.erase(descriptor_update_template_id);
-    descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[descriptor_update_template_id];
-    unique_id_mapping.erase(descriptor_update_template_id);
     lock.unlock();
+
+    auto iter = unique_id_mapping.pop(descriptor_update_template_id);
+    if (iter != unique_id_mapping.end()) {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)iter->second;
+    } else {
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)0;
+    }
+
     layer_data->device_dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
 }
 
@@ -751,12 +763,13 @@ void DispatchUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet de
         return layer_data->device_dispatch_table.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate,
                                                                                  pData);
     uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
+    void *unwrapped_buffer = nullptr;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         descriptorSet = layer_data->Unwrap(descriptorSet);
-        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[template_handle];
+        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)layer_data->Unwrap(descriptorUpdateTemplate);
+        unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
     }
-    void *unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
     layer_data->device_dispatch_table.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, unwrapped_buffer);
     free(unwrapped_buffer);
 }
@@ -770,9 +783,9 @@ void DispatchUpdateDescriptorSetWithTemplateKHR(VkDevice device, VkDescriptorSet
     uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     void *unwrapped_buffer = nullptr;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         descriptorSet = layer_data->Unwrap(descriptorSet);
-        descriptorUpdateTemplate = (VkDescriptorUpdateTemplate)unique_id_mapping[template_handle];
+        descriptorUpdateTemplate = layer_data->Unwrap(descriptorUpdateTemplate);
         unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
     }
     layer_data->device_dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, unwrapped_buffer);
@@ -789,7 +802,7 @@ void DispatchCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer,
     uint64_t template_handle = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
     void *unwrapped_buffer = nullptr;
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
+        read_dispatch_lock_guard_t lock(dispatch_lock);
         descriptorUpdateTemplate = layer_data->Unwrap(descriptorUpdateTemplate);
         layout = layer_data->Unwrap(layout);
         unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(layer_data, template_handle, pData);
@@ -806,7 +819,6 @@ VkResult DispatchGetPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physical
         layer_data->instance_dispatch_table.GetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].display = layer_data->MaybeWrapDisplay(pProperties[idx0].display, layer_data);
         }
@@ -821,7 +833,6 @@ VkResult DispatchGetPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physica
         layer_data->instance_dispatch_table.GetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].displayProperties.display =
                 layer_data->MaybeWrapDisplay(pProperties[idx0].displayProperties.display, layer_data);
@@ -837,7 +848,6 @@ VkResult DispatchGetPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice phy
         layer_data->instance_dispatch_table.GetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             VkDisplayKHR &opt_display = pProperties[idx0].currentDisplay;
             if (opt_display) opt_display = layer_data->MaybeWrapDisplay(opt_display, layer_data);
@@ -853,7 +863,6 @@ VkResult DispatchGetPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice ph
                                                                                                       pPropertyCount, pProperties);
     if (!wrap_handles) return result;
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             VkDisplayKHR &opt_display = pProperties[idx0].displayPlaneProperties.currentDisplay;
             if (opt_display) opt_display = layer_data->MaybeWrapDisplay(opt_display, layer_data);
@@ -869,7 +878,6 @@ VkResult DispatchGetDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDe
                                                                                               pDisplayCount, pDisplays);
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pDisplays) {
     if (!wrap_handles) return result;
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t i = 0; i < *pDisplayCount; ++i) {
             if (pDisplays[i]) pDisplays[i] = layer_data->MaybeWrapDisplay(pDisplays[i], layer_data);
         }
@@ -884,13 +892,11 @@ VkResult DispatchGetDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, Vk
         return layer_data->instance_dispatch_table.GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount,
                                                                                pProperties);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
 
     VkResult result = layer_data->instance_dispatch_table.GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].displayMode = layer_data->WrapNew(pProperties[idx0].displayMode);
         }
@@ -905,14 +911,12 @@ VkResult DispatchGetDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, V
         return layer_data->instance_dispatch_table.GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount,
                                                                                 pProperties);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         display = layer_data->Unwrap(display);
     }
 
     VkResult result =
         layer_data->instance_dispatch_table.GetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties);
     if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
             pProperties[idx0].displayModeProperties.displayMode = layer_data->WrapNew(pProperties[idx0].displayModeProperties.displayMode);
         }
@@ -925,7 +929,6 @@ VkResult DispatchDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarker
     if (!wrap_handles) return layer_data->device_dispatch_table.DebugMarkerSetObjectTagEXT(device, pTagInfo);
     safe_VkDebugMarkerObjectTagInfoEXT local_tag_info(pTagInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_tag_info.object));
         if (it != unique_id_mapping.end()) {
             local_tag_info.object = it->second;
@@ -941,7 +944,6 @@ VkResult DispatchDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarke
     if (!wrap_handles) return layer_data->device_dispatch_table.DebugMarkerSetObjectNameEXT(device, pNameInfo);
     safe_VkDebugMarkerObjectNameInfoEXT local_name_info(pNameInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_name_info.object));
         if (it != unique_id_mapping.end()) {
             local_name_info.object = it->second;
@@ -958,7 +960,6 @@ VkResult DispatchSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsOb
     if (!wrap_handles) return layer_data->device_dispatch_table.SetDebugUtilsObjectTagEXT(device, pTagInfo);
     safe_VkDebugUtilsObjectTagInfoEXT local_tag_info(pTagInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_tag_info.objectHandle));
         if (it != unique_id_mapping.end()) {
             local_tag_info.objectHandle = it->second;
@@ -974,7 +975,6 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
     if (!wrap_handles) return layer_data->device_dispatch_table.SetDebugUtilsObjectNameEXT(device, pNameInfo);
     safe_VkDebugUtilsObjectNameInfoEXT local_name_info(pNameInfo);
     {
-        std::lock_guard<std::mutex> lock(dispatch_lock);
         auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_name_info.objectHandle));
         if (it != unique_id_mapping.end()) {
             local_name_info.objectHandle = it->second;
@@ -1121,7 +1121,18 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
             write('// This intentionally includes a cpp file', file=self.outFile)
             write('#include "vk_safe_struct.cpp"', file=self.outFile)
             self.newline()
-            write('std::mutex dispatch_lock;', file=self.outFile)
+            write('// shared_mutex support added in MSVC 2015 update 2', file=self.outFile)
+            write('#if defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 190023918 && NTDDI_VERSION > NTDDI_WIN10_RS2', file=self.outFile)
+            write('    #include <shared_mutex>', file=self.outFile)
+            write('    typedef std::shared_mutex dispatch_lock_t;', file=self.outFile)
+            write('    typedef std::shared_lock<dispatch_lock_t> read_dispatch_lock_guard_t;', file=self.outFile)
+            write('    typedef std::unique_lock<dispatch_lock_t> write_dispatch_lock_guard_t;', file=self.outFile)
+            write('#else', file=self.outFile)
+            write('    typedef std::mutex dispatch_lock_t;', file=self.outFile)
+            write('    typedef std::unique_lock<dispatch_lock_t> read_dispatch_lock_guard_t;', file=self.outFile)
+            write('    typedef std::unique_lock<dispatch_lock_t> write_dispatch_lock_guard_t;', file=self.outFile)
+            write('#endif', file=self.outFile)
+            write('dispatch_lock_t dispatch_lock;', file=self.outFile)
             self.newline()
             write('// Unique Objects pNext extension handling function', file=self.outFile)
             write('%s' % extension_proc, file=self.outFile)
@@ -1270,10 +1281,6 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
         self.structMembers.append(self.StructMemberData(name=typeName, members=membersInfo))
 
     #
-    # Insert a lock_guard line
-    def lock_guard(self, indent):
-        return '%sstd::lock_guard<std::mutex> lock(dispatch_lock);\n' % indent
-    #
     # Determine if a struct has an NDO as a member or an embedded member
     def struct_contains_ndo(self, struct_item):
         struct_member_dict = dict(self.structMembers)
@@ -1342,26 +1349,24 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
     def build_extension_processing_func(self):
         # Construct helper functions to build and free pNext extension chains
         pnext_proc = ''
-        pnext_proc += 'void *CreateUnwrappedExtensionStructs(ValidationObject *layer_data, const void *pNext) {\n'
+        pnext_proc += 'void WrapPnextChainHandles(ValidationObject *layer_data, const void *pNext) {\n'
         pnext_proc += '    void *cur_pnext = const_cast<void *>(pNext);\n'
-        pnext_proc += '    void *head_pnext = NULL;\n'
-        pnext_proc += '    void *prev_ext_struct = NULL;\n'
-        pnext_proc += '    void *cur_ext_struct = NULL;\n\n'
         pnext_proc += '    while (cur_pnext != NULL) {\n'
         pnext_proc += '        VkBaseOutStructure *header = reinterpret_cast<VkBaseOutStructure *>(cur_pnext);\n\n'
         pnext_proc += '        switch (header->sType) {\n'
         for item in self.pnext_extension_structs:
             struct_info = self.struct_member_dict[item]
+            indent = '                '
+            (tmp_decl, tmp_pre, tmp_post) = self.uniquify_members(struct_info, indent, 'safe_struct->', 0, False, False, False, False)
+            # Only process extension structs containing handles
+            if not tmp_pre:
+                continue
             if struct_info[0].feature_protect is not None:
                 pnext_proc += '#ifdef %s \n' % struct_info[0].feature_protect
             pnext_proc += '            case %s: {\n' % self.structTypes[item].value
-            pnext_proc += '                    safe_%s *safe_struct = new safe_%s;\n' % (item, item)
-            pnext_proc += '                    safe_struct->initialize(reinterpret_cast<const %s *>(cur_pnext));\n' % item
+            pnext_proc += '                    safe_%s *safe_struct = reinterpret_cast<safe_%s *>(cur_pnext);\n' % (item, item)
             # Generate code to unwrap the handles
-            indent = '                '
-            (tmp_decl, tmp_pre, tmp_post) = self.uniquify_members(struct_info, indent, 'safe_struct->', 0, False, False, False, False)
             pnext_proc += tmp_pre
-            pnext_proc += '                    cur_ext_struct = reinterpret_cast<void *>(safe_struct);\n'
             pnext_proc += '                } break;\n'
             if struct_info[0].feature_protect is not None:
                 pnext_proc += '#endif // %s \n' % struct_info[0].feature_protect
@@ -1369,39 +1374,9 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
         pnext_proc += '            default:\n'
         pnext_proc += '                break;\n'
         pnext_proc += '        }\n\n'
-        pnext_proc += '        // Save pointer to the first structure in the pNext chain\n'
-        pnext_proc += '        head_pnext = (head_pnext ? head_pnext : cur_ext_struct);\n\n'
-        pnext_proc += '        // For any extension structure but the first, link the last struct\'s pNext to the current ext struct\n'
-        pnext_proc += '        if (prev_ext_struct) {\n'
-        pnext_proc += '                reinterpret_cast<VkBaseOutStructure *>(prev_ext_struct)->pNext = reinterpret_cast<VkBaseOutStructure *>(cur_ext_struct);\n'
-        pnext_proc += '        }\n'
-        pnext_proc += '        prev_ext_struct = cur_ext_struct;\n\n'
         pnext_proc += '        // Process the next structure in the chain\n'
         pnext_proc += '        cur_pnext = header->pNext;\n'
         pnext_proc += '    }\n'
-        pnext_proc += '    return head_pnext;\n'
-        pnext_proc += '}\n\n'
-        pnext_proc += '// Free a pNext extension chain\n'
-        pnext_proc += 'void FreeUnwrappedExtensionStructs(void *head) {\n'
-        pnext_proc += '    VkBaseOutStructure *curr_ptr = reinterpret_cast<VkBaseOutStructure *>(head);\n'
-        pnext_proc += '    while (curr_ptr) {\n'
-        pnext_proc += '        VkBaseOutStructure *header = curr_ptr;\n'
-        pnext_proc += '        curr_ptr = reinterpret_cast<VkBaseOutStructure *>(header->pNext);\n\n'
-        pnext_proc += '        switch (header->sType) {\n';
-        for item in self.pnext_extension_structs:
-            struct_info = self.struct_member_dict[item]
-            if struct_info[0].feature_protect is not None:
-                pnext_proc += '#ifdef %s \n' % struct_info[0].feature_protect
-            pnext_proc += '            case %s:\n' % self.structTypes[item].value
-            pnext_proc += '                delete reinterpret_cast<safe_%s *>(header);\n' % item
-            pnext_proc += '                break;\n'
-            if struct_info[0].feature_protect is not None:
-                pnext_proc += '#endif // %s \n' % struct_info[0].feature_protect
-            pnext_proc += '\n'
-        pnext_proc += '            default:\n'
-        pnext_proc += '                assert(0);\n'
-        pnext_proc += '        }\n'
-        pnext_proc += '    }\n'
         pnext_proc += '}\n'
         return pnext_proc
 
@@ -1418,7 +1393,6 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
             handle_name = params[-1].find('name')
             create_ndo_code += '%sif (VK_SUCCESS == result) {\n' % (indent)
             indent = self.incIndent(indent)
-            create_ndo_code += '%sstd::lock_guard<std::mutex> lock(dispatch_lock);\n' % (indent)
             ndo_dest = '*%s' % handle_name.text
             if ndo_array == True:
                 create_ndo_code += '%sfor (uint32_t index0 = 0; index0 < %s; index0++) {\n' % (indent, cmd_info[-1].len)
@@ -1448,7 +1422,6 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
                     # This API is freeing an array of handles.  Remove them from the unique_id map.
                     destroy_ndo_code += '%sif ((VK_SUCCESS == result) && (%s)) {\n' % (indent, cmd_info[param].name)
                     indent = self.incIndent(indent)
-                    destroy_ndo_code += '%sstd::unique_lock<std::mutex> lock(dispatch_lock);\n' % (indent)
                     destroy_ndo_code += '%sfor (uint32_t index0 = 0; index0 < %s; index0++) {\n' % (indent, cmd_info[param].len)
                     indent = self.incIndent(indent)
                     destroy_ndo_code += '%s%s handle = %s[index0];\n' % (indent, cmd_info[param].type, cmd_info[param].name)
@@ -1460,26 +1433,27 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
                     destroy_ndo_code += '%s}\n' % indent
                 else:
                     # Remove a single handle from the map
-                    destroy_ndo_code += '%sstd::unique_lock<std::mutex> lock(dispatch_lock);\n' % (indent)
                     destroy_ndo_code += '%suint64_t %s_id = reinterpret_cast<uint64_t &>(%s);\n' % (indent, cmd_info[param].name, cmd_info[param].name)
-                    destroy_ndo_code += '%s%s = (%s)unique_id_mapping[%s_id];\n' % (indent, cmd_info[param].name, cmd_info[param].type, cmd_info[param].name)
-                    destroy_ndo_code += '%sunique_id_mapping.erase(%s_id);\n' % (indent, cmd_info[param].name)
-                    destroy_ndo_code += '%slock.unlock();\n' % (indent)
+                    destroy_ndo_code += '%sauto iter = unique_id_mapping.pop(%s_id);\n' % (indent, cmd_info[param].name)
+                    destroy_ndo_code += '%sif (iter != unique_id_mapping.end()) {\n' % (indent)
+                    indent = self.incIndent(indent)
+                    destroy_ndo_code += '%s%s = (%s)iter->second;\n' % (indent, cmd_info[param].name, cmd_info[param].type)
+                    indent = self.decIndent(indent);
+                    destroy_ndo_code += '%s} else {\n' % (indent)
+                    indent = self.incIndent(indent)
+                    destroy_ndo_code += '%s%s = (%s)0;\n' % (indent, cmd_info[param].name, cmd_info[param].type)
+                    indent = self.decIndent(indent);
+                    destroy_ndo_code += '%s}\n' % (indent)
+
         return ndo_array, destroy_ndo_code
 
     #
     # Clean up local declarations
-    def cleanUpLocalDeclarations(self, indent, prefix, name, len, index, process_pnext):
+    def cleanUpLocalDeclarations(self, indent, prefix, name, len, index):
         cleanup = '%sif (local_%s%s) {\n' % (indent, prefix, name)
         if len is not None:
-            if process_pnext:
-                cleanup += '%s    for (uint32_t %s = 0; %s < %s%s; ++%s) {\n' % (indent, index, index, prefix, len, index)
-                cleanup += '%s        FreeUnwrappedExtensionStructs(const_cast<void *>(local_%s%s[%s].pNext));\n' % (indent, prefix, name, index)
-                cleanup += '%s    }\n' % indent
             cleanup += '%s    delete[] local_%s%s;\n' % (indent, prefix, name)
         else:
-            if process_pnext:
-                cleanup += '%s    FreeUnwrappedExtensionStructs(const_cast<void *>(local_%s%s->pNext));\n' % (indent, prefix, name)
             cleanup += '%s    delete local_%s%s;\n' % (indent, prefix, name)
         cleanup += "%s}\n" % (indent)
         return cleanup
@@ -1576,7 +1550,7 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
                         if first_level_param == True:
                             pre_code += '%s    %s[%s].initialize(&%s[%s]);\n' % (indent, new_prefix, index, member.name, index)
                             if process_pnext:
-                                pre_code += '%s    %s[%s].pNext = CreateUnwrappedExtensionStructs(layer_data, %s[%s].pNext);\n' % (indent, new_prefix, index, new_prefix, index)
+                                pre_code += '%s    WrapPnextChainHandles(layer_data, %s[%s].pNext);\n' % (indent, new_prefix, index)
                         local_prefix = '%s[%s].' % (new_prefix, index)
                         # Process sub-structs in this struct
                         (tmp_decl, tmp_pre, tmp_post) = self.uniquify_members(struct_info, indent, local_prefix, array_index, create_func, destroy_func, destroy_array, False)
@@ -1588,7 +1562,7 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
                         indent = self.decIndent(indent)
                         pre_code += '%s    }\n' % indent
                         if first_level_param == True:
-                            post_code += self.cleanUpLocalDeclarations(indent, prefix, member.name, member.len, index, process_pnext)
+                            post_code += self.cleanUpLocalDeclarations(indent, prefix, member.name, member.len, index)
                     # Single Struct
                     elif ispointer:
                         # Update struct prefix
@@ -1608,11 +1582,11 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
                         pre_code += tmp_pre
                         post_code += tmp_post
                         if process_pnext:
-                            pre_code += '%s    local_%s%s->pNext = CreateUnwrappedExtensionStructs(layer_data, local_%s%s->pNext);\n' % (indent, prefix, member.name, prefix, member.name)
+                            pre_code += '%s    WrapPnextChainHandles(layer_data, local_%s%s->pNext);\n' % (indent, prefix, member.name)
                         indent = self.decIndent(indent)
                         pre_code += '%s    }\n' % indent
                         if first_level_param == True:
-                            post_code += self.cleanUpLocalDeclarations(indent, prefix, member.name, member.len, index, process_pnext)
+                            post_code += self.cleanUpLocalDeclarations(indent, prefix, member.name, member.len, index)
                     else:
                         # Update struct prefix
                         if first_level_param == True:
@@ -1625,7 +1599,7 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
                         pre_code += tmp_pre
                         post_code += tmp_post
                         if process_pnext:
-                            pre_code += '%s    local_%s%s.pNext = CreateUnwrappedExtensionStructs(layer_data, local_%s%s.pNext);\n' % (indent, prefix, member.name, prefix, member.name)
+                            pre_code += '%s    WrapPnextChainHandles(layer_data, local_%s%s.pNext);\n' % (indent, prefix, member.name)
         return decls, pre_code, post_code
     #
     # For a particular API, generate the non-dispatchable-object wrapping/unwrapping code
@@ -1662,7 +1636,7 @@ VkResult DispatchSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsO
                     param_pre_code += destroy_ndo_code
             if param_pre_code:
                 if (not destroy_func) or (destroy_array):
-                    param_pre_code = '%s{\n%s%s%s%s}\n' % ('    ', indent, self.lock_guard(indent), param_pre_code, indent)
+                    param_pre_code = '%s{\n%s%s}\n' % ('    ', param_pre_code, indent)
         return paramdecl, param_pre_code, param_post_code
     #
     # Capture command parameter info needed to wrap NDOs as well as handling some boilerplate code
diff --git a/scripts/layer_chassis_generator.py b/scripts/layer_chassis_generator.py
index 53c6d8eed..c34e5ad81 100644
--- a/scripts/layer_chassis_generator.py
+++ b/scripts/layer_chassis_generator.py
@@ -198,6 +198,7 @@ class LayerChassisOutputGenerator(OutputGenerator):
 
     inline_custom_header_preamble = """
 #define NOMINMAX
+#include <atomic>
 #include <mutex>
 #include <cinttypes>
 #include <stdio.h>
@@ -225,8 +226,8 @@ class LayerChassisOutputGenerator(OutputGenerator):
 #include "vk_typemap_helper.h"
 
 
-extern uint64_t global_unique_id;
-extern std::unordered_map<uint64_t, uint64_t> unique_id_mapping;
+extern std::atomic<uint64_t> global_unique_id;
+extern vl_concurrent_unordered_map<uint64_t, uint64_t, 4> unique_id_mapping;
 """
 
     inline_custom_header_class_definition = """
@@ -239,6 +240,7 @@ enum LayerObjectTypeId {
     LayerObjectTypeParameterValidation,         // Instance or device parameter validation layer object
     LayerObjectTypeObjectTracker,               // Instance or device object tracker layer object
     LayerObjectTypeCoreValidation,              // Instance or device core validation layer object
+    LayerObjectTypeBestPractices,               // Instance or device best practices layer object
 };
 
 struct TEMPLATE_STATE {
@@ -261,8 +263,13 @@ typedef enum ValidationCheckDisables {
     VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET,
     VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE,
     VALIDATION_CHECK_DISABLE_QUERY_VALIDATION,
+    VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION,
 } ValidationCheckDisables;
 
+typedef enum VkValidationFeatureEnable {
+    VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES,
+} VkValidationFeatureEnable;
+
 
 // CHECK_DISABLED struct is a container for bools that can block validation checks from being performed.
 // These bools are all "false" by default meaning that all checks are enabled. Enum values can be specified
@@ -274,6 +281,7 @@ struct CHECK_DISABLED {
     bool idle_descriptor_set;                       // Skip check to verify that descriptor set is not in-use
     bool push_constant_range;                       // Skip push constant range checks
     bool query_validation;                          // Disable all core validation query-related checks
+    bool image_layout_validation;                   // Disable image layout validation
     bool object_tracking;                           // Disable object lifetime validation
     bool core_checks;                               // Disable core validation checks
     bool thread_safety;                             // Disable thread safety validation
@@ -287,6 +295,7 @@ struct CHECK_DISABLED {
 struct CHECK_ENABLED {
     bool gpu_validation;
     bool gpu_validation_reserve_binding_slot;
+    bool best_practices;
 
     void SetAll(bool value) { std::fill(&gpu_validation, &gpu_validation_reserve_binding_slot + 1, value); }
 };
@@ -338,7 +347,7 @@ class ValidationObject {
 
         // Handle Wrapping Data
         // Reverse map display handles
-        std::unordered_map<VkDisplayKHR, uint64_t> display_id_reverse_mapping;
+        vl_concurrent_unordered_map<VkDisplayKHR, uint64_t, 0> display_id_reverse_mapping;
         // Wrapping Descriptor Template Update structures requires access to the template createinfo structs
         std::unordered_map<uint64_t, std::unique_ptr<TEMPLATE_STATE>> desc_template_createinfo_map;
         struct SubpassesUsageStates {
@@ -354,31 +363,33 @@ class ValidationObject {
         std::unordered_map<VkDescriptorPool, std::unordered_set<VkDescriptorSet>> pool_descriptor_sets_map;
 
 
-        // Unwrap a handle.  Must hold lock.
+        // Unwrap a handle.
         template <typename HandleType>
         HandleType Unwrap(HandleType wrappedHandle) {
-            // TODO: don't use operator[] here.
-            return (HandleType)unique_id_mapping[reinterpret_cast<uint64_t const &>(wrappedHandle)];
+            auto iter = unique_id_mapping.find(reinterpret_cast<uint64_t const &>(wrappedHandle));
+            if (iter == unique_id_mapping.end())
+                return (HandleType)0;
+            return (HandleType)iter->second;
         }
 
-        // Wrap a newly created handle with a new unique ID, and return the new ID -- must hold lock.
+        // Wrap a newly created handle with a new unique ID, and return the new ID.
         template <typename HandleType>
         HandleType WrapNew(HandleType newlyCreatedHandle) {
             auto unique_id = global_unique_id++;
-            unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
+            unique_id_mapping.insert_or_assign(unique_id, reinterpret_cast<uint64_t const &>(newlyCreatedHandle));
             return (HandleType)unique_id;
         }
 
-        // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup. Must hold lock.
+        // Specialized handling for VkDisplayKHR. Adds an entry to enable reverse-lookup.
         VkDisplayKHR WrapDisplay(VkDisplayKHR newlyCreatedHandle, ValidationObject *map_data) {
             auto unique_id = global_unique_id++;
-            unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
-            map_data->display_id_reverse_mapping[newlyCreatedHandle] = unique_id;
+            unique_id_mapping.insert_or_assign(unique_id, reinterpret_cast<uint64_t const &>(newlyCreatedHandle));
+            map_data->display_id_reverse_mapping.insert_or_assign(newlyCreatedHandle, unique_id);
             return (VkDisplayKHR)unique_id;
         }
 
         // VkDisplayKHR objects don't have a single point of creation, so we need to see if one already exists in the map before
-        // creating another. Must hold lock.
+        // creating another.
         VkDisplayKHR MaybeWrapDisplay(VkDisplayKHR handle, ValidationObject *map_data) {
             // See if this display is already known
             auto it = map_data->display_id_reverse_mapping.find(handle);
@@ -426,10 +437,11 @@ class ValidationObject {
 
 std::unordered_map<void*, ValidationObject*> layer_data_map;
 
-// Global unique object identifier.  All increments must be guarded by a lock.
-uint64_t global_unique_id = 1;
-// Map uniqueID to actual object handle
-std::unordered_map<uint64_t, uint64_t> unique_id_mapping;
+// Global unique object identifier.
+std::atomic<uint64_t> global_unique_id(1ULL);
+// Map uniqueID to actual object handle. Accesses to the map itself are
+// internally synchronized.
+vl_concurrent_unordered_map<uint64_t, uint64_t, 4> unique_id_mapping;
 
 // TODO: This variable controls handle wrapping -- in the future it should be hooked
 //       up to the new VALIDATION_FEATURES extension. Temporarily, control with a compile-time flag.
@@ -473,6 +485,9 @@ bool wrap_handles = false;
 #if BUILD_CORE_VALIDATION
 #include "core_validation.h"
 #endif
+#if BUILD_BEST_PRACTICES
+#include "best_practices.h"
+#endif
 
 namespace vulkan_layer_chassis {
 
@@ -503,7 +518,7 @@ static void InstanceExtensionWhitelist(ValidationObject *layer_data, const VkIns
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         // Check for recognized instance extensions
         if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kInstanceExtensionNames)) {
-            log_msg(layer_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+            log_msg(layer_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                     kVUIDUndefined,
                     "Instance Extension %s is not supported by this layer.  Using this extension may adversely affect validation "
                     "results and/or produce undefined behavior.",
@@ -517,7 +532,7 @@ static void DeviceExtensionWhitelist(ValidationObject *layer_data, const VkDevic
     for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) {
         // Check for recognized device extensions
         if (!white_list(pCreateInfo->ppEnabledExtensionNames[i], kDeviceExtensionNames)) {
-            log_msg(layer_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
+            log_msg(layer_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
                     kVUIDUndefined,
                     "Device Extension %s is not supported by this layer.  Using this extension may adversely affect validation "
                     "results and/or produce undefined behavior.",
@@ -544,12 +559,17 @@ static const std::unordered_map<std::string, VkValidationFeatureEnableEXT> VkVal
     {"VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT", VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT},
 };
 
+static const std::unordered_map<std::string, VkValidationFeatureEnable> VkValFeatureEnableLookup2 = {
+    {"VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES", VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES},
+};
+
 static const std::unordered_map<std::string, ValidationCheckDisables> ValidationDisableLookup = {
     {"VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE", VALIDATION_CHECK_DISABLE_COMMAND_BUFFER_STATE},
     {"VALIDATION_CHECK_DISABLE_OBJECT_IN_USE", VALIDATION_CHECK_DISABLE_OBJECT_IN_USE},
     {"VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET", VALIDATION_CHECK_DISABLE_IDLE_DESCRIPTOR_SET},
     {"VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE", VALIDATION_CHECK_DISABLE_PUSH_CONSTANT_RANGE},
     {"VALIDATION_CHECK_DISABLE_QUERY_VALIDATION", VALIDATION_CHECK_DISABLE_QUERY_VALIDATION},
+    {"VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION", VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION},
 };
 
 // Set the local disable flag for the appropriate VALIDATION_CHECK_DISABLE enum
@@ -570,6 +590,9 @@ void SetValidationDisable(CHECK_DISABLED* disable_data, const ValidationCheckDis
         case VALIDATION_CHECK_DISABLE_QUERY_VALIDATION:
             disable_data->query_validation = true;
             break;
+        case VALIDATION_CHECK_DISABLE_IMAGE_LAYOUT_VALIDATION:
+            disable_data->image_layout_validation = true;
+            break;
         default:
             assert(true);
     }
@@ -619,6 +642,16 @@ void SetValidationFeatureEnable(CHECK_ENABLED *enable_data, const VkValidationFe
     }
 }
 
+void SetValidationFeatureEnable(CHECK_ENABLED *enable_data, const VkValidationFeatureEnable feature_enable) {
+    switch(feature_enable) {
+        case VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES:
+            enable_data->best_practices = true;
+            break;
+        default:
+            break;
+    }
+}
+
 // Set the local disable flag for settings specified through the VK_EXT_validation_flags extension
 void SetValidationFlags(CHECK_DISABLED* disables, const VkValidationFlagsEXT* val_flags_struct) {
     for (uint32_t i = 0; i < val_flags_struct->disabledValidationCheckCount; ++i) {
@@ -663,6 +696,11 @@ void SetLocalEnableSetting(std::string list_of_enables, std::string delimiter, C
             auto result = VkValFeatureEnableLookup.find(token);
             if (result != VkValFeatureEnableLookup.end()) {
                 SetValidationFeatureEnable(enables, result->second);
+            } else {
+                auto result2 = VkValFeatureEnableLookup2.find(token);
+                if (result2 != VkValFeatureEnableLookup2.end()) {
+                    SetValidationFeatureEnable(enables, result2->second);
+                }
             }
         }
         list_of_enables.erase(0, pos + delimiter.length());
@@ -834,6 +872,14 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreat
     core_checks->container_type = LayerObjectTypeCoreValidation;
     core_checks->api_version = api_version;
 #endif
+#if BUILD_BEST_PRACTICES
+    auto best_practices = new BestPractices;
+    if (local_enables.best_practices) {
+        local_object_dispatch.emplace_back(best_practices);
+    }
+    best_practices->container_type = LayerObjectTypeBestPractices;
+    best_practices->api_version = api_version;
+#endif
 
     // If handle wrapping is disabled via the ValidationFeatures extension, override build flag
     if (local_disables.handle_wrapping) {
@@ -893,6 +939,12 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreat
     core_checks->disabled = framework->disabled;
     core_checks->instance_state = core_checks;
 #endif
+#if BUILD_BEST_PRACTICES
+    best_practices->report_data = framework->report_data;
+    best_practices->instance_dispatch_table = framework->instance_dispatch_table;
+    best_practices->enabled = framework->enabled;
+    best_practices->disabled = framework->disabled;
+#endif
 
     for (auto intercept : framework->object_dispatch) {
         intercept->PostCallRecordCreateInstance(pCreateInfo, pAllocator, pInstance, result);
@@ -968,7 +1020,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice
         item->device_extensions = device_extensions;
     }
 
-    std::unique_ptr<safe_VkDeviceCreateInfo> modified_create_info(new safe_VkDeviceCreateInfo(pCreateInfo));
+    safe_VkDeviceCreateInfo modified_create_info(pCreateInfo);
 
     bool skip = false;
     for (auto intercept : instance_interceptor->object_dispatch) {
@@ -978,10 +1030,10 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice
     }
     for (auto intercept : instance_interceptor->object_dispatch) {
         auto lock = intercept->write_lock();
-        intercept->PreCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice, modified_create_info);
+        intercept->PreCallRecordCreateDevice(gpu, pCreateInfo, pAllocator, pDevice, &modified_create_info);
     }
 
-    VkResult result = fpCreateDevice(gpu, reinterpret_cast<VkDeviceCreateInfo *>(modified_create_info.get()), pAllocator, pDevice);
+    VkResult result = fpCreateDevice(gpu, reinterpret_cast<VkDeviceCreateInfo *>(&modified_create_info), pAllocator, pDevice);
     if (result != VK_SUCCESS) {
         return result;
     }
@@ -1033,6 +1085,13 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice gpu, const VkDevice
         device_interceptor->object_dispatch.emplace_back(core_checks);
     }
 #endif
+#if BUILD_BEST_PRACTICES
+    auto best_practices = new BestPractices;
+    best_practices->container_type = LayerObjectTypeBestPractices;
+    if (instance_interceptor->enabled.best_practices) {
+        device_interceptor->object_dispatch.emplace_back(best_practices);
+    }
+#endif
 
     // Set per-intercept common data items
     for (auto dev_intercept : device_interceptor->object_dispatch) {
@@ -1173,25 +1232,31 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
     auto layer_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
     bool skip = false;
 
-#ifndef BUILD_CORE_VALIDATION
-    struct PIPELINE_STATE {};
+#ifdef BUILD_CORE_VALIDATION
+    create_ray_tracing_pipeline_api_state crtpl_state{};
+#else
+    struct create_ray_tracing_pipeline_api_state {
+        const VkRayTracingPipelineCreateInfoNV* pCreateInfos;
+    } crtpl_state;
 #endif
-
-    std::vector<std::unique_ptr<PIPELINE_STATE>> pipe_state;
+    crtpl_state.pCreateInfos = pCreateInfos;
 
     for (auto intercept : layer_data->object_dispatch) {
         auto lock = intercept->write_lock();
-        skip |= intercept->PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, &pipe_state);
+        skip |= intercept->PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos,
+                                                                      pAllocator, pPipelines, &crtpl_state);
         if (skip) return VK_ERROR_VALIDATION_FAILED_EXT;
     }
     for (auto intercept : layer_data->object_dispatch) {
         auto lock = intercept->write_lock();
-        intercept->PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        intercept->PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+                                                            pPipelines, &crtpl_state);
     }
     VkResult result = DispatchCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
     for (auto intercept : layer_data->object_dispatch) {
         auto lock = intercept->write_lock();
-        intercept->PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result, &pipe_state);
+        intercept->PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator,
+                                                             pPipelines, result, &crtpl_state);
     }
     return result;
 }
@@ -1368,7 +1433,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
         virtual VkResult CoreLayerMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches)  { return VK_SUCCESS; };
         virtual VkResult CoreLayerGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData)  { return VK_SUCCESS; };
 
-        // Allow additional parameter for CreateGraphicsPipelines
+        // Allow additional state parameter for CreateGraphicsPipelines
         virtual bool PreCallValidateCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* cgpl_state) {
             return PreCallValidateCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         };
@@ -1378,13 +1443,14 @@ VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
         virtual void PostCallRecordCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* cgpl_state) {
             PostCallRecordCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
         };
-        virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
-            PreCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
-        };
+
         // Allow additional state parameter for CreateComputePipelines
         virtual bool PreCallValidateCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state)  {
             return PreCallValidateCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         };
+        virtual void PreCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
+            PreCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        };
         virtual void PostCallRecordCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
             PostCallRecordCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
         };
@@ -1393,6 +1459,9 @@ VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
         virtual bool PreCallValidateCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* pipe_state)  {
             return PreCallValidateCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
         };
+        virtual void PreCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, void* ccpl_state) {
+            PreCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
+        };
         virtual void PostCallRecordCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines, VkResult result, void* pipe_state) {
             PostCallRecordCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines, result);
         };
@@ -1422,7 +1491,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
         };
 
         // Modify a parameter to CreateDevice
-        virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, std::unique_ptr<safe_VkDeviceCreateInfo> &modified_create_info) {
+        virtual void PreCallRecordCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice, safe_VkDeviceCreateInfo *modified_create_info) {
             PreCallRecordCreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
         };
 """
diff --git a/scripts/object_tracker_generator.py b/scripts/object_tracker_generator.py
index a435d0e4b..ffb6a9df9 100644
--- a/scripts/object_tracker_generator.py
+++ b/scripts/object_tracker_generator.py
@@ -164,6 +164,7 @@ class ObjectTrackerOutputGenerator(OutputGenerator):
             'vkAcquirePerformanceConfigurationINTEL',
             'vkReleasePerformanceConfigurationINTEL',
             'vkQueueSetPerformanceConfigurationINTEL',
+            'vkCreateFramebuffer',
             ]
         # These VUIDS are not implicit, but are best handled in this layer. Codegen for vkDestroy calls will generate a key
         # which is translated here into a good VU.  Saves ~40 checks.
@@ -791,7 +792,7 @@ class ObjectTrackerOutputGenerator(OutputGenerator):
                         pre_code += '%s}\n' % indent
                         indent = self.decIndent(indent)
                         pre_code += '%s}\n' % indent
-                    # Single Struct
+                    # Single Struct Pointer
                     elif ispointer:
                         # Update struct prefix
                         new_prefix = '%s%s->' % (prefix, member.name)
@@ -803,6 +804,13 @@ class ObjectTrackerOutputGenerator(OutputGenerator):
                         pre_code += tmp_pre
                         indent = self.decIndent(indent)
                         pre_code += '%s}\n' % indent
+                    # Single Nested Struct
+                    else:
+                        # Update struct prefix
+                        new_prefix = '%s%s.' % (prefix, member.name)
+                        # Process sub-structs
+                        tmp_pre = self.validate_objects(struct_info, indent, new_prefix, array_index, disp_name, member.type, False)
+                        pre_code += tmp_pre
         return pre_code
     #
     # For a particular API, generate the object handling code
@@ -837,7 +845,6 @@ class ObjectTrackerOutputGenerator(OutputGenerator):
     #
     # Capture command parameter info needed to create, destroy, and validate objects
     def genCmd(self, cmdinfo, cmdname, alias):
-
         # Add struct-member type information to command parameter information
         OutputGenerator.genCmd(self, cmdinfo, cmdname, alias)
         members = cmdinfo.elem.findall('.//param')
@@ -857,7 +864,6 @@ class ObjectTrackerOutputGenerator(OutputGenerator):
 
         # Generate member info
         membersInfo = []
-        constains_extension_structs = False
         allocator = 'nullptr'
         for member in members:
             # Get type and name of member
@@ -981,7 +987,6 @@ class ObjectTrackerOutputGenerator(OutputGenerator):
                             post_cr_func_decl = post_cr_func_decl.replace('{', '{\n    if (result != VK_SUCCESS) return;')
                     self.appendSection('command', post_cr_func_decl)
 
-
                     self.appendSection('command', post_call_record)
                     self.appendSection('command', '}')
 
diff --git a/scripts/parameter_validation_generator.py b/scripts/parameter_validation_generator.py
index 4bc12b135..8aa410f18 100644
--- a/scripts/parameter_validation_generator.py
+++ b/scripts/parameter_validation_generator.py
@@ -140,7 +140,6 @@ class ParameterValidationOutputGenerator(OutputGenerator):
             'vkCreateRenderPass2KHR',
             'vkCreateBuffer',
             'vkCreateImage',
-            'vkCreateImageView',
             'vkCreateGraphicsPipelines',
             'vkCreateComputePipelines',
             "vkCreateRayTracingPipelinesNV",
@@ -159,6 +158,7 @@ class ParameterValidationOutputGenerator(OutputGenerator):
             'vkCmdDrawIndexedIndirect',
             'vkCmdClearAttachments',
             'vkCmdCopyImage',
+            'vkCmdBindIndexBuffer',
             'vkCmdBlitImage',
             'vkCmdCopyBufferToImage',
             'vkCmdCopyImageToBuffer',
@@ -180,6 +180,8 @@ class ParameterValidationOutputGenerator(OutputGenerator):
             'vkCreateAccelerationStructureNV',
             'vkGetAccelerationStructureHandleNV',
             'vkCmdBuildAccelerationStructureNV',
+            'vkCreateFramebuffer',
+            'vkCmdSetLineStippleEXT',
             ]
 
         # Commands to ignore
@@ -610,7 +612,7 @@ class ParameterValidationOutputGenerator(OutputGenerator):
                         enum_entry += '%s, ' % name
                 enum_entry += '};\n'
                 if self.featureExtraProtect is not None:
-                    enum_entry += '#endif // %s' % self.featureExtraProtect
+                    enum_entry += '#endif // %s\n' % self.featureExtraProtect
                 self.enumValueLists += enum_entry
     #
     # Capture command parameter info to be used for param check code generation.
@@ -927,6 +929,9 @@ class ParameterValidationOutputGenerator(OutputGenerator):
         if lenValue:
             count_required_vuid = self.GetVuid(vuid_tag_name, "%s-arraylength" % (lenValue.name))
             array_required_vuid = self.GetVuid(vuid_tag_name, "%s-parameter" % (value.name))
+            # TODO: Remove workaround for missing optional tag in vk.xml
+            if array_required_vuid == '"VUID-VkFramebufferCreateInfo-pAttachments-parameter"':
+                return []
             # This is an array with a pointer to a count value
             if lenValue.ispointer:
                 # If count and array parameters are optional, there will be no validation
@@ -1194,25 +1199,26 @@ class ParameterValidationOutputGenerator(OutputGenerator):
                     elif value.type in self.handleTypes:
                         if not self.isHandleOptional(value, None):
                             usedLines.append('skip |= validate_required_handle("{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec))
-                    elif value.type in self.flags:
-                        flagBitsName = value.type.replace('Flags', 'FlagBits')
-                        if not flagBitsName in self.flagBits:
-                            vuid = self.GetVuid(vuid_name_tag, "%s-zerobitmask" % (value.name))
-                            usedLines.append('skip |= validate_reserved_flags("{}", {ppp}"{}"{pps}, {pf}{}, {});\n'.format(funcName, valueDisplayName, value.name, vuid, pf=valuePrefix, **postProcSpec))
-                        else:
-                            if value.isoptional:
-                                flagsRequired = 'false'
-                                vuid = self.GetVuid(vuid_name_tag, "%s-parameter" % (value.name))
-                            else:
-                                flagsRequired = 'true'
-                                vuid = self.GetVuid(vuid_name_tag, "%s-requiredbitmask" % (value.name))
-                            allFlagsName = 'All' + flagBitsName
-                            usedLines.append('skip |= validate_flags("{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {}, false, {});\n'.format(funcName, valueDisplayName, flagBitsName, allFlagsName, value.name, flagsRequired, vuid, pf=valuePrefix, **postProcSpec))
-                    elif value.type in self.flagBits:
-                        flagsRequired = 'false' if value.isoptional else 'true'
-                        allFlagsName = 'All' + value.type
-                        vuid = self.GetVuid(vuid_name_tag, "%s-parameter" % (value.name))
-                        usedLines.append('skip |= validate_flags("{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {}, true, {});\n'.format(funcName, valueDisplayName, value.type, allFlagsName, value.name, flagsRequired, vuid, pf=valuePrefix, **postProcSpec))
+                    elif value.type in self.flags and value.type.replace('Flags', 'FlagBits') not in self.flagBits:
+                        vuid = self.GetVuid(vuid_name_tag, "%s-zerobitmask" % (value.name))
+                        usedLines.append('skip |= validate_reserved_flags("{}", {ppp}"{}"{pps}, {pf}{}, {});\n'.format(funcName, valueDisplayName, value.name, vuid, pf=valuePrefix, **postProcSpec))
+                    elif value.type in self.flags or value.type in self.flagBits:
+                        if value.type in self.flags:
+                            flagBitsName = value.type.replace('Flags', 'FlagBits')
+                            flagsType = 'kOptionalFlags' if value.isoptional else 'kRequiredFlags'
+                            invalidVuid = self.GetVuid(vuid_name_tag, "%s-parameter" % (value.name))
+                            zeroVuid = self.GetVuid(vuid_name_tag, "%s-requiredbitmask" % (value.name))
+                        elif value.type in self.flagBits:
+                            flagBitsName = value.type
+                            flagsType = 'kOptionalSingleBit' if value.isoptional else 'kRequiredSingleBit'
+                            invalidVuid = self.GetVuid(vuid_name_tag, "%s-parameter" % (value.name))
+                            zeroVuid = invalidVuid
+                        allFlagsName = 'All' + flagBitsName
+
+                        invalid_vuid = self.GetVuid(vuid_name_tag, "%s-parameter" % (value.name))
+                        allFlagsName = 'All' + flagBitsName
+                        zeroVuidArg = '' if value.isoptional else ', ' + zeroVuid
+                        usedLines.append('skip |= validate_flags("{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {}, {}{});\n'.format(funcName, valueDisplayName, flagBitsName, allFlagsName, value.name, flagsType, invalidVuid, zeroVuidArg, pf=valuePrefix, **postProcSpec))
                     elif value.isbool:
                         usedLines.append('skip |= validate_bool32("{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec))
                     elif value.israngedenum:
@@ -1291,7 +1297,7 @@ class ParameterValidationOutputGenerator(OutputGenerator):
                     for param in command.params:
                         params_text += '%s, ' % param.name
                     params_text = params_text[:-2] + ');\n'
-                    cmdDef += '    skip |= manual_PreCallValidate'+ command.name[2:] + '(' + params_text
+                    cmdDef += '    if (!skip) skip |= manual_PreCallValidate'+ command.name[2:] + '(' + params_text
                 cmdDef += '%sreturn skip;\n' % indent
                 cmdDef += '}\n'
                 self.validation.append(cmdDef)
diff --git a/scripts/thread_safety_generator.py b/scripts/thread_safety_generator.py
index e4ec3759b..da0a1f906 100644
--- a/scripts/thread_safety_generator.py
+++ b/scripts/thread_safety_generator.py
@@ -119,7 +119,7 @@ class ThreadOutputGenerator(OutputGenerator):
 
     inline_copyright_message = """
 // This file is ***GENERATED***.  Do Not Edit.
-// See layer_chassis_dispatch_generator.py for modifications.
+// See thread_safety_generator.py for modifications.
 
 /* Copyright (c) 2015-2019 The Khronos Group Inc.
  * Copyright (c) 2015-2019 Valve Corporation
@@ -149,7 +149,8 @@ class ThreadOutputGenerator(OutputGenerator):
     inline_custom_header_preamble = """
 #pragma once
 
-#include <condition_variable>
+#include <chrono>
+#include <thread>
 #include <mutex>
 #include <vector>
 #include <unordered_set>
@@ -242,32 +243,53 @@ public:
     }
 };
 
+#define THREAD_SAFETY_BUCKETS_LOG2 6
+#define THREAD_SAFETY_BUCKETS (1 << THREAD_SAFETY_BUCKETS_LOG2)
+
+template <typename T> inline uint32_t ThreadSafetyHashObject(T object)
+{
+    uint64_t u64 = (uint64_t)(uintptr_t)object;
+    uint32_t hash = (uint32_t)(u64 >> 32) + (uint32_t)u64;
+    hash ^= (hash >> THREAD_SAFETY_BUCKETS_LOG2) ^ (hash >> (2*THREAD_SAFETY_BUCKETS_LOG2));
+    hash &= (THREAD_SAFETY_BUCKETS-1);
+    return hash;
+}
+
 template <typename T>
 class counter {
 public:
     const char *typeName;
     VkDebugReportObjectTypeEXT objectType;
     debug_report_data **report_data;
-    small_unordered_map<T, object_use_data> uses;
-    std::mutex counter_lock;
-    std::condition_variable counter_condition;
 
+    // Per-bucket locking, to reduce contention.
+    struct CounterBucket {
+        small_unordered_map<T, object_use_data> uses;
+        std::mutex counter_lock;
+    };
+
+    CounterBucket buckets[THREAD_SAFETY_BUCKETS];
+    CounterBucket &GetBucket(T object)
+    {
+        return buckets[ThreadSafetyHashObject(object)];
+    }
 
     void StartWrite(T object) {
         if (object == VK_NULL_HANDLE) {
             return;
         }
+        auto &bucket = GetBucket(object);
         bool skip = false;
         loader_platform_thread_id tid = loader_platform_get_thread_id();
-        std::unique_lock<std::mutex> lock(counter_lock);
-        if (!uses.contains(object)) {
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        if (!bucket.uses.contains(object)) {
             // There is no current use of the object.  Record writer thread.
-            struct object_use_data *use_data = &uses[object];
+            struct object_use_data *use_data = &bucket.uses[object];
             use_data->reader_count = 0;
             use_data->writer_count = 1;
             use_data->thread = tid;
         } else {
-            struct object_use_data *use_data = &uses[object];
+            struct object_use_data *use_data = &bucket.uses[object];
             if (use_data->reader_count == 0) {
                 // There are no readers.  Two writers just collided.
                 if (use_data->thread != tid) {
@@ -277,12 +299,9 @@ public:
                         "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
                         typeName, (uint64_t)use_data->thread, (uint64_t)tid);
                     if (skip) {
-                        // Wait for thread-safe access to object instead of skipping call.
-                        while (uses.contains(object)) {
-                            counter_condition.wait(lock);
-                        }
+                        WaitForObjectIdle(bucket, object, lock);
                         // There is now no current use of the object.  Record writer thread.
-                        struct object_use_data *new_use_data = &uses[object];
+                        struct object_use_data *new_use_data = &bucket.uses[object];
                         new_use_data->thread = tid;
                         new_use_data->reader_count = 0;
                         new_use_data->writer_count = 1;
@@ -305,12 +324,9 @@ public:
                         "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
                         typeName, (uint64_t)use_data->thread, (uint64_t)tid);
                     if (skip) {
-                        // Wait for thread-safe access to object instead of skipping call.
-                        while (uses.contains(object)) {
-                            counter_condition.wait(lock);
-                        }
+                        WaitForObjectIdle(bucket, object, lock);
                         // There is now no current use of the object.  Record writer thread.
-                        struct object_use_data *new_use_data = &uses[object];
+                        struct object_use_data *new_use_data = &bucket.uses[object];
                         new_use_data->thread = tid;
                         new_use_data->reader_count = 0;
                         new_use_data->writer_count = 1;
@@ -332,73 +348,81 @@ public:
         if (object == VK_NULL_HANDLE) {
             return;
         }
+        auto &bucket = GetBucket(object);
         // Object is no longer in use
-        std::unique_lock<std::mutex> lock(counter_lock);
-        uses[object].writer_count -= 1;
-        if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
-            uses.erase(object);
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        struct object_use_data *use_data = &bucket.uses[object];
+        use_data->writer_count -= 1;
+        if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
+            bucket.uses.erase(object);
         }
-        // Notify any waiting threads that this object may be safe to use
-        lock.unlock();
-        counter_condition.notify_all();
     }
 
     void StartRead(T object) {
         if (object == VK_NULL_HANDLE) {
             return;
         }
+        auto &bucket = GetBucket(object);
         bool skip = false;
         loader_platform_thread_id tid = loader_platform_get_thread_id();
-        std::unique_lock<std::mutex> lock(counter_lock);
-        if (!uses.contains(object)) {
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        if (!bucket.uses.contains(object)) {
             // There is no current use of the object.  Record reader count
-            struct object_use_data *use_data = &uses[object];
+            struct object_use_data *use_data = &bucket.uses[object];
             use_data->reader_count = 1;
             use_data->writer_count = 0;
             use_data->thread = tid;
-        } else if (uses[object].writer_count > 0 && uses[object].thread != tid) {
+        } else if (bucket.uses[object].writer_count > 0 && bucket.uses[object].thread != tid) {
             // There is a writer of the object.
-            skip |= false;
-            log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object), kVUID_Threading_MultipleThreads,
+            skip |= log_msg(*report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, objectType, (uint64_t)(object),
+                kVUID_Threading_MultipleThreads,
                 "THREADING ERROR : object of type %s is simultaneously used in "
                 "thread 0x%" PRIx64 " and thread 0x%" PRIx64,
-                typeName, (uint64_t)uses[object].thread, (uint64_t)tid);
+                typeName, (uint64_t)bucket.uses[object].thread, (uint64_t)tid);
             if (skip) {
-                // Wait for thread-safe access to object instead of skipping call.
-                while (uses.contains(object)) {
-                    counter_condition.wait(lock);
-                }
+                WaitForObjectIdle(bucket, object, lock);
                 // There is no current use of the object.  Record reader count
-                struct object_use_data *use_data = &uses[object];
+                struct object_use_data *use_data = &bucket.uses[object];
                 use_data->reader_count = 1;
                 use_data->writer_count = 0;
                 use_data->thread = tid;
             } else {
-                uses[object].reader_count += 1;
+                bucket.uses[object].reader_count += 1;
             }
         } else {
             // There are other readers of the object.  Increase reader count
-            uses[object].reader_count += 1;
+            bucket.uses[object].reader_count += 1;
         }
     }
     void FinishRead(T object) {
         if (object == VK_NULL_HANDLE) {
             return;
         }
-        std::unique_lock<std::mutex> lock(counter_lock);
-        uses[object].reader_count -= 1;
-        if ((uses[object].reader_count == 0) && (uses[object].writer_count == 0)) {
-            uses.erase(object);
+        auto &bucket = GetBucket(object);
+        std::unique_lock<std::mutex> lock(bucket.counter_lock);
+        struct object_use_data *use_data = &bucket.uses[object];
+        use_data->reader_count -= 1;
+        if ((use_data->reader_count == 0) && (use_data->writer_count == 0)) {
+            bucket.uses.erase(object);
         }
-        // Notify any waiting threads that this object may be safe to use
-        lock.unlock();
-        counter_condition.notify_all();
     }
     counter(const char *name = "", VkDebugReportObjectTypeEXT type = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, debug_report_data **rep_data = nullptr) {
         typeName = name;
         objectType = type;
         report_data = rep_data;
     }
+
+private:
+    void WaitForObjectIdle(CounterBucket &bucket, T object, std::unique_lock<std::mutex> &lock) {
+        // Wait for thread-safe access to object instead of skipping call.
+        // Don't use condition_variable to wait because it should be extremely
+        // rare to have collisions, but signaling would be very frequent.
+        while (bucket.uses.contains(object)) {
+            lock.unlock();
+            std::this_thread::sleep_for(std::chrono::microseconds(1));
+            lock.lock();
+        }
+    }
 };
 
 
@@ -412,8 +436,17 @@ public:
         return std::unique_lock<std::mutex>(validation_object_mutex, std::defer_lock);
     }
 
-    std::mutex command_pool_lock;
-    std::unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;
+    // Per-bucket locking, to reduce contention.
+    struct CommandBufferBucket {
+        std::mutex command_pool_lock;
+        small_unordered_map<VkCommandBuffer, VkCommandPool> command_pool_map;
+    };
+
+    CommandBufferBucket buckets[THREAD_SAFETY_BUCKETS];
+    CommandBufferBucket &GetBucket(VkCommandBuffer object)
+    {
+        return buckets[ThreadSafetyHashObject(object)];
+    }
 
     counter<VkCommandBuffer> c_VkCommandBuffer;
     counter<VkDevice> c_VkDevice;
@@ -475,8 +508,9 @@ WRAPPER(uint64_t)
     // VkCommandBuffer needs check for implicit use of command pool
     void StartWriteObject(VkCommandBuffer object, bool lockPool = true) {
         if (lockPool) {
-            std::unique_lock<std::mutex> lock(command_pool_lock);
-            VkCommandPool pool = command_pool_map[object];
+            auto &bucket = GetBucket(object);
+            std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+            VkCommandPool pool = bucket.command_pool_map[object];
             lock.unlock();
             StartWriteObject(pool);
         }
@@ -485,15 +519,17 @@ WRAPPER(uint64_t)
     void FinishWriteObject(VkCommandBuffer object, bool lockPool = true) {
         c_VkCommandBuffer.FinishWrite(object);
         if (lockPool) {
-            std::unique_lock<std::mutex> lock(command_pool_lock);
-            VkCommandPool pool = command_pool_map[object];
+            auto &bucket = GetBucket(object);
+            std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+            VkCommandPool pool = bucket.command_pool_map[object];
             lock.unlock();
             FinishWriteObject(pool);
         }
     }
     void StartReadObject(VkCommandBuffer object) {
-        std::unique_lock<std::mutex> lock(command_pool_lock);
-        VkCommandPool pool = command_pool_map[object];
+        auto &bucket = GetBucket(object);
+        std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+        VkCommandPool pool = bucket.command_pool_map[object];
         lock.unlock();
         // We set up a read guard against the "Contents" counter to catch conflict vs. vkResetCommandPool and vkDestroyCommandPool
         // while *not* establishing a read guard against the command pool counter itself to avoid false postives for
@@ -502,9 +538,10 @@ WRAPPER(uint64_t)
         c_VkCommandBuffer.StartRead(object);
     }
     void FinishReadObject(VkCommandBuffer object) {
+        auto &bucket = GetBucket(object);
         c_VkCommandBuffer.FinishRead(object);
-        std::unique_lock<std::mutex> lock(command_pool_lock);
-        VkCommandPool pool = command_pool_map[object];
+        std::unique_lock<std::mutex> lock(bucket.command_pool_lock);
+        VkCommandPool pool = bucket.command_pool_map[object];
         lock.unlock();
         c_VkCommandPoolContents.FinishRead(pool);
     } """
@@ -524,9 +561,10 @@ void ThreadSafety::PostCallRecordAllocateCommandBuffers(VkDevice device, const V
 
     // Record mapping from command buffer to command pool
     if(pCommandBuffers) {
-        std::lock_guard<std::mutex> lock(command_pool_lock);
         for (uint32_t index = 0; index < pAllocateInfo->commandBufferCount; index++) {
-            command_pool_map[pCommandBuffers[index]] = pAllocateInfo->commandPool;
+            auto &bucket = GetBucket(pCommandBuffers[index]);
+            std::lock_guard<std::mutex> lock(bucket.command_pool_lock);
+            bucket.command_pool_map[pCommandBuffers[index]] = pAllocateInfo->commandPool;
         }
     }
 }
@@ -562,9 +600,10 @@ void ThreadSafety::PreCallRecordFreeCommandBuffers(VkDevice device, VkCommandPoo
             FinishWriteObject(pCommandBuffers[index], lockCommandPool);
         }
         // Holding the lock for the shortest time while we update the map
-        std::lock_guard<std::mutex> lock(command_pool_lock);
         for (uint32_t index = 0; index < commandBufferCount; index++) {
-            command_pool_map.erase(pCommandBuffers[index]);
+            auto &bucket = GetBucket(pCommandBuffers[index]);
+            std::lock_guard<std::mutex> lock(bucket.command_pool_lock);
+            bucket.command_pool_map.erase(pCommandBuffers[index]);
         }
     }
 }
diff --git a/scripts/vk_validation_stats.py b/scripts/vk_validation_stats.py
index c34a04969..8f6c87fcc 100755
--- a/scripts/vk_validation_stats.py
+++ b/scripts/vk_validation_stats.py
@@ -144,6 +144,7 @@ def printHelp():
     print ("                                [ -csv  [ <csv_out_filename>]  ]")
     print ("                                [ -html [ <html_out_filename>] ]")
     print ("                                [ -export_header ]")
+    print ("                                [ -summary ]")
     print ("                                [ -verbose ]")
     print ("                                [ -help ]")
     print ("\n  The vk_validation_stats script parses validation layer source files to")
@@ -162,6 +163,7 @@ def printHelp():
     print (" -html [filename]  output the error database in html to <html_database_filename>,")
     print ("                   defaults to 'validation_error_database.html'")
     print (" -export_header    export a new VUID error text header file to <%s>" % header_filename)
+    print (" -summary          output summary of VUID coverage")
     print (" -verbose          show your work (to stdout)")
 
 class ValidationJSON:
@@ -571,7 +573,8 @@ static const vuid_spec_text_pair vuid_spec_text[] = {
             hfile.write('</table>\n</body>\n</html>\n')
 
     def export_header(self):
-        print("\n Exporting header file to: %s" % header_filename)
+        if verbose_mode:
+            print("\n Exporting header file to: %s" % header_filename)
         with open (header_filename, 'w') as hfile:
             hfile.write(self.header_version)
             hfile.write(self.header_preamble)
@@ -632,6 +635,7 @@ def main(argv):
     csv_out = False
     html_out = False
     header_out = False
+    show_summary = False
 
     if (1 > len(argv)):
         printHelp()
@@ -672,6 +676,8 @@ def main(argv):
             header_out = True
         elif (arg in ['-verbose']):
             verbose_mode = True
+        elif (arg in ['-summary']):
+            show_summary = True
         elif (arg in ['-help', '-h']):
             printHelp()
             sys.exit()
@@ -725,20 +731,21 @@ def main(argv):
         print("  %d unassigned" % len(val_tests.unassigned_vuids))
 
     # Process stats
-    print("\nValidation Statistics (using validusage.json version %s)" % val_json.apiversion)
-    print("  VUIDs defined in JSON file:  %04d explicit, %04d implicit, %04d total." % (exp_json, imp_json, all_json))
-    print("  VUIDs checked in layer code: %04d explicit, %04d implicit, %04d total." % (exp_checks, imp_checks, all_checks))
-    print("  VUIDs tested in layer tests: %04d explicit, %04d implicit, %04d total." % (exp_tests, imp_tests, all_tests))
-
-    print("\nVUID check coverage")
-    print("  Explicit VUIDs checked: %.1f%% (%d checked vs %d defined)" % ((100.0 * exp_checks / exp_json), exp_checks, exp_json))
-    print("  Implicit VUIDs checked: %.1f%% (%d checked vs %d defined)" % ((100.0 * imp_checks / imp_json), imp_checks, imp_json))
-    print("  Overall VUIDs checked:  %.1f%% (%d checked vs %d defined)" % ((100.0 * all_checks / all_json), all_checks, all_json))
-
-    print("\nVUID test coverage")
-    print("  Explicit VUIDs tested: %.1f%% (%d tested vs %d checks)" % ((100.0 * exp_tests / exp_checks), exp_tests, exp_checks))
-    print("  Implicit VUIDs tested: %.1f%% (%d tested vs %d checks)" % ((100.0 * imp_tests / imp_checks), imp_tests, imp_checks))
-    print("  Overall VUIDs tested:  %.1f%% (%d tested vs %d checks)" % ((100.0 * all_tests / all_checks), all_tests, all_checks))
+    if show_summary:
+        print("\nValidation Statistics (using validusage.json version %s)" % val_json.apiversion)
+        print("  VUIDs defined in JSON file:  %04d explicit, %04d implicit, %04d total." % (exp_json, imp_json, all_json))
+        print("  VUIDs checked in layer code: %04d explicit, %04d implicit, %04d total." % (exp_checks, imp_checks, all_checks))
+        print("  VUIDs tested in layer tests: %04d explicit, %04d implicit, %04d total." % (exp_tests, imp_tests, all_tests))
+
+        print("\nVUID check coverage")
+        print("  Explicit VUIDs checked: %.1f%% (%d checked vs %d defined)" % ((100.0 * exp_checks / exp_json), exp_checks, exp_json))
+        print("  Implicit VUIDs checked: %.1f%% (%d checked vs %d defined)" % ((100.0 * imp_checks / imp_json), imp_checks, imp_json))
+        print("  Overall VUIDs checked:  %.1f%% (%d checked vs %d defined)" % ((100.0 * all_checks / all_json), all_checks, all_json))
+
+        print("\nVUID test coverage")
+        print("  Explicit VUIDs tested: %.1f%% (%d tested vs %d checks)" % ((100.0 * exp_tests / exp_checks), exp_tests, exp_checks))
+        print("  Implicit VUIDs tested: %.1f%% (%d tested vs %d checks)" % ((100.0 * imp_tests / imp_checks), imp_tests, imp_checks))
+        print("  Overall VUIDs tested:  %.1f%% (%d tested vs %d checks)" % ((100.0 * all_tests / all_checks), all_tests, all_checks))
 
     # Report status of a single VUID
     if len(get_vuid_status) > 1:
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 0f7645c08..57b247348 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -61,7 +61,7 @@ endif()
 set(LIBGLM_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/libs)
 
 set(COMMON_CPP vklayertests_pipeline_shader.cpp vklayertests_buffer_image_memory_sampler.cpp vklayertests_others.cpp vklayertests_descriptor_renderpass_framebuffer.cpp
-				vklayertests_command.cpp vkpositivelayertests.cpp vkrenderframework.cpp vktestbinding.cpp vktestframework.cpp test_environment.cpp)
+				vklayertests_command.cpp vklayertests_imageless_framebuffer.cpp vkpositivelayertests.cpp vkrenderframework.cpp vktestbinding.cpp vktestframework.cpp test_environment.cpp)
 
 if(NOT WIN32)
     # extra setup for out-of-tree builds
@@ -93,6 +93,13 @@ if(NOT TARGET vulkan)
         message(STATUS "VULKAN_LOADER_INSTALL_DIR specified, using find_package to locate Vulkan")
     elseif(ENV{VULKAN_LOADER_INSTALL_DIR})
         message(STATUS "VULKAN_LOADER_INSTALL_DIR environment variable specified, using find_package to locate Vulkan")
+    else()
+        set(LOCAL_LOADER TRUE)
+        if(CMAKE_CL_64)
+            set(VULKAN_LOADER_INSTALL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../external/x64")
+        else()
+            set(VULKAN_LOADER_INSTALL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../external/x86")
+        endif()
     endif()
     set(
         CMAKE_PREFIX_PATH
@@ -162,7 +169,7 @@ if(WIN32)
                            COMMAND xcopy /Y /I ${SRC_GTEST_DLLS} ${DST_GTEST_DLLS})
     endif()
     # Copy the loader shared lib (if supplied) to the test application directory so the test app finds it.
-    if(VULKAN_LOADER_INSTALL_DIR)
+    if(VULKAN_LOADER_INSTALL_DIR AND NOT LOCAL_LOADER)
         add_custom_command(TARGET vk_layer_validation_tests POST_BUILD
                            COMMAND ${CMAKE_COMMAND} -E copy ${VULKAN_LOADER_INSTALL_DIR}/bin/vulkan-1.dll
                                    $<TARGET_FILE_DIR:vk_layer_validation_tests>)
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 927b2aa3d..f87ffa46a 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -27,8 +27,8 @@
 #include "layer_validation_tests.h"
 
 VkFormat FindSupportedDepthStencilFormat(VkPhysicalDevice phy) {
-    VkFormat ds_formats[] = {VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT};
-    for (uint32_t i = 0; i < sizeof(ds_formats); i++) {
+    const VkFormat ds_formats[] = {VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT_S8_UINT};
+    for (uint32_t i = 0; i < size(ds_formats); ++i) {
         VkFormatProperties format_props;
         vkGetPhysicalDeviceFormatProperties(phy, ds_formats[i], &format_props);
 
@@ -178,7 +178,7 @@ extern "C" void *ReleaseNullFence(void *arg) {
 }
 
 void TestRenderPassCreate(ErrorMonitor *error_monitor, const VkDevice device, const VkRenderPassCreateInfo *create_info,
-                          bool rp2Supported, const char *rp1_vuid, const char *rp2_vuid) {
+                          bool rp2_supported, const char *rp1_vuid, const char *rp2_vuid) {
     VkRenderPass render_pass = VK_NULL_HANDLE;
     VkResult err;
 
@@ -189,7 +189,7 @@ void TestRenderPassCreate(ErrorMonitor *error_monitor, const VkDevice device, co
         error_monitor->VerifyFound();
     }
 
-    if (rp2Supported && rp2_vuid) {
+    if (rp2_supported && rp2_vuid) {
         PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR =
             (PFN_vkCreateRenderPass2KHR)vkGetDeviceProcAddr(device, "vkCreateRenderPass2KHR");
         safe_VkRenderPassCreateInfo2KHR create_info2;
@@ -202,6 +202,29 @@ void TestRenderPassCreate(ErrorMonitor *error_monitor, const VkDevice device, co
     }
 }
 
+void PositiveTestRenderPassCreate(ErrorMonitor *error_monitor, const VkDevice device, const VkRenderPassCreateInfo *create_info,
+                                  bool rp2_supported) {
+    VkRenderPass render_pass = VK_NULL_HANDLE;
+    VkResult err;
+
+    error_monitor->ExpectSuccess();
+    err = vkCreateRenderPass(device, create_info, nullptr, &render_pass);
+    if (err == VK_SUCCESS) vkDestroyRenderPass(device, render_pass, nullptr);
+    error_monitor->VerifyNotFound();
+
+    if (rp2_supported) {
+        PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR =
+            (PFN_vkCreateRenderPass2KHR)vkGetDeviceProcAddr(device, "vkCreateRenderPass2KHR");
+        safe_VkRenderPassCreateInfo2KHR create_info2;
+        ConvertVkRenderPassCreateInfoToV2KHR(create_info, &create_info2);
+
+        error_monitor->ExpectSuccess();
+        err = vkCreateRenderPass2KHR(device, create_info2.ptr(), nullptr, &render_pass);
+        if (err == VK_SUCCESS) vkDestroyRenderPass(device, render_pass, nullptr);
+        error_monitor->VerifyNotFound();
+    }
+}
+
 void TestRenderPass2KHRCreate(ErrorMonitor *error_monitor, const VkDevice device, const VkRenderPassCreateInfo2KHR *create_info,
                               const char *rp2_vuid) {
     VkRenderPass render_pass = VK_NULL_HANDLE;
@@ -473,16 +496,17 @@ void CreateImageTest(VkLayerTest &test, const VkImageCreateInfo *pCreateInfo, st
     }
 }
 
-void CreateBufferViewTest(VkLayerTest &test, const VkBufferViewCreateInfo *pCreateInfo, std::string code) {
+void CreateBufferViewTest(VkLayerTest &test, const VkBufferViewCreateInfo *pCreateInfo, const std::vector<std::string> &codes) {
     VkResult err;
     VkBufferView view = VK_NULL_HANDLE;
-    if (code.length())
-        test.Monitor()->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, code);
+    if (codes.size())
+        std::for_each(codes.begin(), codes.end(),
+                      [&](const std::string &s) { test.Monitor()->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, s); });
     else
         test.Monitor()->ExpectSuccess();
 
     err = vkCreateBufferView(test.device(), pCreateInfo, NULL, &view);
-    if (code.length())
+    if (codes.size())
         test.Monitor()->VerifyFound();
     else
         test.Monitor()->VerifyNotFound();
@@ -772,6 +796,22 @@ void VkLayerTest::VKTriangleTest(BsoFailSelect failCase) {
             pipelineobj.SetInputAssembly(&ia_state);
             break;
         }
+        case BsoFailLineStipple: {
+            pipelineobj.MakeDynamic(VK_DYNAMIC_STATE_LINE_STIPPLE_EXT);
+            VkPipelineInputAssemblyStateCreateInfo ia_state = {};
+            ia_state.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
+            ia_state.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+            pipelineobj.SetInputAssembly(&ia_state);
+
+            VkPipelineRasterizationLineStateCreateInfoEXT line_state = {};
+            line_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
+            line_state.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT;
+            line_state.stippledLineEnable = VK_TRUE;
+            line_state.lineStippleFactor = 0;
+            line_state.lineStipplePattern = 0;
+            pipelineobj.SetLineState(&line_state);
+            break;
+        }
         case BsoFailDepthBias: {
             pipelineobj.MakeDynamic(VK_DYNAMIC_STATE_DEPTH_BIAS);
             VkPipelineRasterizationStateCreateInfo rs_state = {};
@@ -1436,7 +1476,7 @@ void CreatePipelineHelper::InitShaderInfo() {
 
 void CreatePipelineHelper::InitRasterizationInfo() {
     rs_state_ci_.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
-    rs_state_ci_.pNext = nullptr;
+    rs_state_ci_.pNext = &line_state_ci_;
     rs_state_ci_.flags = 0;
     rs_state_ci_.depthClampEnable = VK_FALSE;
     rs_state_ci_.rasterizerDiscardEnable = VK_FALSE;
@@ -1447,6 +1487,15 @@ void CreatePipelineHelper::InitRasterizationInfo() {
     rs_state_ci_.lineWidth = 1.0F;
 }
 
+void CreatePipelineHelper::InitLineRasterizationInfo() {
+    line_state_ci_.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
+    line_state_ci_.pNext = nullptr;
+    line_state_ci_.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;
+    line_state_ci_.stippledLineEnable = VK_FALSE;
+    line_state_ci_.lineStippleFactor = 0;
+    line_state_ci_.lineStipplePattern = 0;
+}
+
 void CreatePipelineHelper::InitBlendStateInfo() {
     cb_ci_.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
     cb_ci_.logicOpEnable = VK_FALSE;
@@ -1507,6 +1556,7 @@ void CreatePipelineHelper::InitInfo() {
     InitDynamicStateInfo();
     InitShaderInfo();
     InitRasterizationInfo();
+    InitLineRasterizationInfo();
     InitBlendStateInfo();
     InitGraphicsPipelineInfo();
     InitPipelineCacheInfo();
diff --git a/tests/layer_validation_tests.h b/tests/layer_validation_tests.h
index 2e564d8f4..5ef980370 100644
--- a/tests/layer_validation_tests.h
+++ b/tests/layer_validation_tests.h
@@ -80,7 +80,8 @@ enum BsoFailSelect {
     BsoFailIndexBufferBadSize,
     BsoFailIndexBufferBadOffset,
     BsoFailIndexBufferBadMapSize,
-    BsoFailIndexBufferBadMapOffset
+    BsoFailIndexBufferBadMapOffset,
+    BsoFailLineStipple,
 };
 
 static const char bindStateMinimalShaderText[] = "#version 450\nvoid main() {}\n";
@@ -437,6 +438,7 @@ struct CreatePipelineHelper {
     VkPipelineLayoutObj pipeline_layout_;
     VkPipelineDynamicStateCreateInfo dyn_state_ci_ = {};
     VkPipelineRasterizationStateCreateInfo rs_state_ci_ = {};
+    VkPipelineRasterizationLineStateCreateInfoEXT line_state_ci_ = {};
     VkPipelineColorBlendAttachmentState cb_attachments_ = {};
     VkPipelineColorBlendStateCreateInfo cb_ci_ = {};
     VkGraphicsPipelineCreateInfo gp_ci_ = {};
@@ -457,6 +459,7 @@ struct CreatePipelineHelper {
     void InitDynamicStateInfo();
     void InitShaderInfo();
     void InitRasterizationInfo();
+    void InitLineRasterizationInfo();
     void InitBlendStateInfo();
     void InitGraphicsPipelineInfo();
     void InitPipelineCacheInfo();
@@ -475,7 +478,7 @@ struct CreatePipelineHelper {
     // info_override can be any callable that takes a CreatePipelineHeper &
     // flags, error can be any args accepted by "SetDesiredFailure".
     template <typename Test, typename OverrideFunc, typename Error>
-    static void OneshotTest(Test &test, OverrideFunc &info_override, const VkFlags flags, const std::vector<Error> &errors,
+    static void OneshotTest(Test &test, const OverrideFunc &info_override, const VkFlags flags, const std::vector<Error> &errors,
                             bool positive_test = false) {
         CreatePipelineHelper helper(test);
         helper.InitInfo();
@@ -493,7 +496,8 @@ struct CreatePipelineHelper {
     }
 
     template <typename Test, typename OverrideFunc, typename Error>
-    static void OneshotTest(Test &test, OverrideFunc &info_override, const VkFlags flags, Error error, bool positive_test = false) {
+    static void OneshotTest(Test &test, const OverrideFunc &info_override, const VkFlags flags, Error error,
+                            bool positive_test = false) {
         OneshotTest(test, info_override, flags, std::vector<Error>(1, error), positive_test);
     }
 };
@@ -530,7 +534,7 @@ struct CreateComputePipelineHelper {
     // info_override can be any callable that takes a CreatePipelineHeper &
     // flags, error can be any args accepted by "SetDesiredFailure".
     template <typename Test, typename OverrideFunc, typename Error>
-    static void OneshotTest(Test &test, OverrideFunc &info_override, const VkFlags flags, const std::vector<Error> &errors,
+    static void OneshotTest(Test &test, const OverrideFunc &info_override, const VkFlags flags, const std::vector<Error> &errors,
                             bool positive_test = false) {
         CreateComputePipelineHelper helper(test);
         helper.InitInfo();
@@ -548,7 +552,8 @@ struct CreateComputePipelineHelper {
     }
 
     template <typename Test, typename OverrideFunc, typename Error>
-    static void OneshotTest(Test &test, OverrideFunc &info_override, const VkFlags flags, Error error, bool positive_test = false) {
+    static void OneshotTest(Test &test, const OverrideFunc &info_override, const VkFlags flags, Error error,
+                            bool positive_test = false) {
         OneshotTest(test, info_override, flags, std::vector<Error>(1, error), positive_test);
     }
 };
@@ -594,7 +599,7 @@ struct CreateNVRayTracingPipelineHelper {
     // info_override can be any callable that takes a CreateNVRayTracingPipelineHelper &
     // flags, error can be any args accepted by "SetDesiredFailure".
     template <typename Test, typename OverrideFunc, typename Error>
-    static void OneshotTest(Test &test, OverrideFunc &info_override, const std::vector<Error> &errors,
+    static void OneshotTest(Test &test, const OverrideFunc &info_override, const std::vector<Error> &errors,
                             const VkFlags flags = VK_DEBUG_REPORT_ERROR_BIT_EXT) {
         CreateNVRayTracingPipelineHelper helper(test);
         helper.InitInfo();
@@ -607,13 +612,13 @@ struct CreateNVRayTracingPipelineHelper {
     }
 
     template <typename Test, typename OverrideFunc, typename Error>
-    static void OneshotTest(Test &test, OverrideFunc &info_override, Error error,
+    static void OneshotTest(Test &test, const OverrideFunc &info_override, Error error,
                             const VkFlags flags = VK_DEBUG_REPORT_ERROR_BIT_EXT) {
         OneshotTest(test, info_override, std::vector<Error>(1, error), flags);
     }
 
     template <typename Test, typename OverrideFunc>
-    static void OneshotPositiveTest(Test &test, OverrideFunc &info_override,
+    static void OneshotPositiveTest(Test &test, const OverrideFunc &info_override,
                                     const VkDebugReportFlagsEXT message_flag_mask = VK_DEBUG_REPORT_ERROR_BIT_EXT) {
         CreateNVRayTracingPipelineHelper helper(test);
         helper.InitInfo();
@@ -737,7 +742,9 @@ extern "C" void *AddToCommandBuffer(void *arg);
 extern "C" void *ReleaseNullFence(void *arg);
 
 void TestRenderPassCreate(ErrorMonitor *error_monitor, const VkDevice device, const VkRenderPassCreateInfo *create_info,
-                          bool rp2Supported, const char *rp1_vuid, const char *rp2_vuid);
+                          bool rp2_supported, const char *rp1_vuid, const char *rp2_vuid);
+void PositiveTestRenderPassCreate(ErrorMonitor *error_monitor, const VkDevice device, const VkRenderPassCreateInfo *create_info,
+                                  bool rp2_supported);
 void TestRenderPass2KHRCreate(ErrorMonitor *error_monitor, const VkDevice device, const VkRenderPassCreateInfo2KHR *create_info,
                               const char *rp2_vuid);
 void TestRenderPassBegin(ErrorMonitor *error_monitor, const VkDevice device, const VkCommandBuffer command_buffer,
@@ -771,7 +778,7 @@ void CreateBufferTest(VkLayerTest &test, const VkBufferCreateInfo *pCreateInfo,
 
 void CreateImageTest(VkLayerTest &test, const VkImageCreateInfo *pCreateInfo, std::string code = "");
 
-void CreateBufferViewTest(VkLayerTest &test, const VkBufferViewCreateInfo *pCreateInfo, std::string code = "");
+void CreateBufferViewTest(VkLayerTest &test, const VkBufferViewCreateInfo *pCreateInfo, const std::vector<std::string> &codes);
 
 void CreateImageViewTest(VkLayerTest &test, const VkImageViewCreateInfo *pCreateInfo, std::string code = "");
 
diff --git a/tests/layers/CMakeLists.txt b/tests/layers/CMakeLists.txt
index eed7a1fd6..bf0fea01b 100644
--- a/tests/layers/CMakeLists.txt
+++ b/tests/layers/CMakeLists.txt
@@ -97,13 +97,13 @@ AddVkLayer(device_profile_api device_profile_api.cpp ${PROJECT_SOURCE_DIR}/layer
 # --------------------------------------------------------------------------------------------------------------------------------
 
 target_include_directories(${TEST_LAYER_NAME}
-                           PRIVATE ${VulkanHeaders_INCLUDE_DIR}
-                                   ${CMAKE_CURRENT_SOURCE_DIR}
+                           PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}
                                    ${PROJECT_SOURCE_DIR}/layers
                                    ${CMAKE_CURRENT_BINARY_DIR}
                                    ${PROJECT_BINARY_DIR}
                                    ${PROJECT_BINARY_DIR}/layers
-                                   ${CMAKE_BINARY_DIR})
+                                   ${CMAKE_BINARY_DIR}
+                                   ${VulkanHeaders_INCLUDE_DIR})
 
 if(WIN32)
     # For Windows, copy necessary device_profile_api layer files for the layer_tests
diff --git a/tests/vklayertests_buffer_image_memory_sampler.cpp b/tests/vklayertests_buffer_image_memory_sampler.cpp
index a507c1a67..b8e7817df 100644
--- a/tests/vklayertests_buffer_image_memory_sampler.cpp
+++ b/tests/vklayertests_buffer_image_memory_sampler.cpp
@@ -427,110 +427,6 @@ TEST_F(VkLayerTest, SparseResidencyImageCreateUnsupportedSamples) {
     CreateImageTest(*this, &image_create_info, "VUID-VkImageCreateInfo-imageType-00976");
 }
 
-TEST_F(VkLayerTest, InvalidMemoryAliasing) {
-    TEST_DESCRIPTION(
-        "Create a buffer and image, allocate memory, and bind the buffer and image to memory such that they will alias.");
-    VkResult err;
-    bool pass;
-    ASSERT_NO_FATAL_FAILURE(Init());
-
-    VkBuffer buffer, buffer2;
-    VkImage image;
-    VkImage image2;
-    VkDeviceMemory mem;      // buffer will be bound first
-    VkDeviceMemory mem_img;  // image bound first
-    VkMemoryRequirements buff_mem_reqs, img_mem_reqs;
-    VkMemoryRequirements buff_mem_reqs2, img_mem_reqs2;
-
-    VkBufferCreateInfo buf_info = {};
-    buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
-    buf_info.pNext = NULL;
-    buf_info.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
-    buf_info.size = 256;
-    buf_info.queueFamilyIndexCount = 0;
-    buf_info.pQueueFamilyIndices = NULL;
-    buf_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-    buf_info.flags = 0;
-    err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer);
-    ASSERT_VK_SUCCESS(err);
-
-    vkGetBufferMemoryRequirements(m_device->device(), buffer, &buff_mem_reqs);
-
-    VkImageCreateInfo image_create_info = {};
-    image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
-    image_create_info.pNext = NULL;
-    image_create_info.imageType = VK_IMAGE_TYPE_2D;
-    image_create_info.format = VK_FORMAT_R8G8B8A8_UNORM;
-    image_create_info.extent.width = 64;
-    image_create_info.extent.height = 64;
-    image_create_info.extent.depth = 1;
-    image_create_info.mipLevels = 1;
-    image_create_info.arrayLayers = 1;
-    image_create_info.samples = VK_SAMPLE_COUNT_1_BIT;
-    // Image tiling must be optimal to trigger error when aliasing linear buffer
-    image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
-    image_create_info.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
-    image_create_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
-    image_create_info.queueFamilyIndexCount = 0;
-    image_create_info.pQueueFamilyIndices = NULL;
-    image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
-    image_create_info.flags = 0;
-
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image);
-    ASSERT_VK_SUCCESS(err);
-    err = vkCreateImage(m_device->device(), &image_create_info, NULL, &image2);
-    ASSERT_VK_SUCCESS(err);
-
-    vkGetImageMemoryRequirements(m_device->device(), image, &img_mem_reqs);
-
-    VkMemoryAllocateInfo alloc_info = {};
-    alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
-    alloc_info.pNext = NULL;
-    alloc_info.memoryTypeIndex = 0;
-    // Ensure memory is big enough for both bindings
-    alloc_info.allocationSize = buff_mem_reqs.size + img_mem_reqs.size;
-    pass = m_device->phy().set_memory_type(buff_mem_reqs.memoryTypeBits & img_mem_reqs.memoryTypeBits, &alloc_info,
-                                           VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-    if (!pass) {
-        printf("%s Failed to set memory type.\n", kSkipPrefix);
-        vkDestroyBuffer(m_device->device(), buffer, NULL);
-        vkDestroyImage(m_device->device(), image, NULL);
-        vkDestroyImage(m_device->device(), image2, NULL);
-        return;
-    }
-    err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem);
-    ASSERT_VK_SUCCESS(err);
-    err = vkBindBufferMemory(m_device->device(), buffer, mem, 0);
-    ASSERT_VK_SUCCESS(err);
-
-    vkGetImageMemoryRequirements(m_device->device(), image2, &img_mem_reqs2);
-
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT, "UNASSIGNED-CoreValidation-MemTrack-InvalidAliasing");
-    // VALIDATION FAILURE due to image mapping overlapping buffer mapping
-    err = vkBindImageMemory(m_device->device(), image, mem, 0);
-    m_errorMonitor->VerifyFound();
-
-    // Now correctly bind image2 to second mem allocation before incorrectly
-    // aliasing buffer2
-    err = vkCreateBuffer(m_device->device(), &buf_info, NULL, &buffer2);
-    ASSERT_VK_SUCCESS(err);
-    err = vkAllocateMemory(m_device->device(), &alloc_info, NULL, &mem_img);
-    ASSERT_VK_SUCCESS(err);
-    err = vkBindImageMemory(m_device->device(), image2, mem_img, 0);
-    ASSERT_VK_SUCCESS(err);
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_WARNING_BIT_EXT, "UNASSIGNED-CoreValidation-MemTrack-InvalidAliasing");
-    vkGetBufferMemoryRequirements(m_device->device(), buffer2, &buff_mem_reqs2);
-    err = vkBindBufferMemory(m_device->device(), buffer2, mem_img, 0);
-    m_errorMonitor->VerifyFound();
-
-    vkDestroyBuffer(m_device->device(), buffer, NULL);
-    vkDestroyBuffer(m_device->device(), buffer2, NULL);
-    vkDestroyImage(m_device->device(), image, NULL);
-    vkDestroyImage(m_device->device(), image2, NULL);
-    vkFreeMemory(m_device->device(), mem, NULL);
-    vkFreeMemory(m_device->device(), mem_img, NULL);
-}
-
 TEST_F(VkLayerTest, InvalidMemoryMapping) {
     TEST_DESCRIPTION("Attempt to map memory in a number of incorrect ways");
     VkResult err;
@@ -3328,7 +3224,7 @@ TEST_F(VkLayerTest, InvalidBufferViewCreateInfoEntries) {
     buff_view_ci.buffer = bad_buffer.handle();
     buff_view_ci.format = format_with_uniform_texel_support;
     buff_view_ci.range = VK_WHOLE_SIZE;
-    CreateBufferViewTest(*this, &buff_view_ci, "VUID-VkBufferViewCreateInfo-buffer-00932");
+    CreateBufferViewTest(*this, &buff_view_ci, {"VUID-VkBufferViewCreateInfo-buffer-00932"});
 
     // Create a better test buffer
     const VkBufferCreateInfo buffer_info = VkBufferObj::create_info(resource_size, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT);
@@ -3338,31 +3234,35 @@ TEST_F(VkLayerTest, InvalidBufferViewCreateInfoEntries) {
     // Offset must be less than the size of the buffer, so set it equal to the buffer size to cause an error
     buff_view_ci.buffer = buffer.handle();
     buff_view_ci.offset = buffer.create_info().size;
-    CreateBufferViewTest(*this, &buff_view_ci, "VUID-VkBufferViewCreateInfo-offset-00925");
+    CreateBufferViewTest(*this, &buff_view_ci, {"VUID-VkBufferViewCreateInfo-offset-00925"});
+
+    // Offset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment so add 1 to ensure it is not
+    buff_view_ci.offset = minTexelBufferOffsetAlignment + 1;
+    CreateBufferViewTest(*this, &buff_view_ci, {"VUID-VkBufferViewCreateInfo-offset-02749"});
 
     // Set offset to acceptable value for range tests
     buff_view_ci.offset = minTexelBufferOffsetAlignment;
     // Setting range equal to 0 will cause an error to occur
     buff_view_ci.range = 0;
-    CreateBufferViewTest(*this, &buff_view_ci, "VUID-VkBufferViewCreateInfo-range-00928");
+    CreateBufferViewTest(*this, &buff_view_ci, {"VUID-VkBufferViewCreateInfo-range-00928"});
 
     uint32_t format_size = FormatElementSize(buff_view_ci.format);
     // Range must be a multiple of the element size of format, so add one to ensure it is not
     buff_view_ci.range = format_size + 1;
-    CreateBufferViewTest(*this, &buff_view_ci, "VUID-VkBufferViewCreateInfo-range-00929");
+    CreateBufferViewTest(*this, &buff_view_ci, {"VUID-VkBufferViewCreateInfo-range-00929"});
 
     // Twice the element size of format multiplied by VkPhysicalDeviceLimits::maxTexelBufferElements guarantees range divided by the
     // element size is greater than maxTexelBufferElements, causing failure
     buff_view_ci.range = 2 * format_size * dev_limits.maxTexelBufferElements;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkBufferViewCreateInfo-range-00930");
-    CreateBufferViewTest(*this, &buff_view_ci, "VUID-VkBufferViewCreateInfo-offset-00931");
+    CreateBufferViewTest(*this, &buff_view_ci,
+                         {"VUID-VkBufferViewCreateInfo-range-00930", "VUID-VkBufferViewCreateInfo-offset-00931"});
 
     // Set rage to acceptable value for buffer tests
     buff_view_ci.format = format_without_texel_support;
     buff_view_ci.range = VK_WHOLE_SIZE;
 
     // `buffer` was created using VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT so we can use that for the first buffer test
-    CreateBufferViewTest(*this, &buff_view_ci, "VUID-VkBufferViewCreateInfo-buffer-00933");
+    CreateBufferViewTest(*this, &buff_view_ci, {"VUID-VkBufferViewCreateInfo-buffer-00933"});
 
     // Create a new buffer using VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT
     const VkBufferCreateInfo storage_buffer_info =
@@ -3371,7 +3271,121 @@ TEST_F(VkLayerTest, InvalidBufferViewCreateInfoEntries) {
     storage_buffer.init(*m_device, storage_buffer_info, (VkMemoryPropertyFlags)VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
     buff_view_ci.buffer = storage_buffer.handle();
-    CreateBufferViewTest(*this, &buff_view_ci, "VUID-VkBufferViewCreateInfo-buffer-00934");
+    CreateBufferViewTest(*this, &buff_view_ci, {"VUID-VkBufferViewCreateInfo-buffer-00934"});
+}
+
+TEST_F(VkLayerTest, InvalidTexelBufferAlignment) {
+    TEST_DESCRIPTION("Test VK_EXT_texel_buffer_alignment.");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+    std::array<const char *, 1> required_device_extensions = {{VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME}};
+    for (auto device_extension : required_device_extensions) {
+        if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
+            m_device_extension_names.push_back(device_extension);
+        } else {
+            printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
+            return;
+        }
+    }
+
+    if (DeviceIsMockICD() || DeviceSimulation()) {
+        printf("%s MockICD does not support this feature, skipping tests\n", kSkipPrefix);
+        return;
+    }
+
+    PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
+        (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
+    ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
+
+    // Create a device that enables texel_buffer_alignment
+    auto texel_buffer_alignment_features = lvl_init_struct<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>();
+    auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&texel_buffer_alignment_features);
+    vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
+    texel_buffer_alignment_features.texelBufferAlignment = VK_TRUE;
+
+    VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT align_props = {};
+    align_props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT;
+    VkPhysicalDeviceProperties2 pd_props2 = {};
+    pd_props2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
+    pd_props2.pNext = &align_props;
+    vkGetPhysicalDeviceProperties2(gpu(), &pd_props2);
+
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2));
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    const VkFormat format_with_uniform_texel_support = VK_FORMAT_R8G8B8A8_UNORM;
+
+    const VkDeviceSize resource_size = 1024;
+    VkBufferCreateInfo buffer_info = VkBufferObj::create_info(
+        resource_size, VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT);
+    VkBufferObj buffer;
+    buffer.init(*m_device, buffer_info, (VkMemoryPropertyFlags)VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+    // Create a test buffer view
+    VkBufferViewCreateInfo buff_view_ci = {};
+    buff_view_ci.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
+    buff_view_ci.buffer = buffer.handle();
+    buff_view_ci.format = format_with_uniform_texel_support;
+    buff_view_ci.range = VK_WHOLE_SIZE;
+
+    buff_view_ci.offset = 1;
+    std::vector<std::string> expectedErrors;
+    if (buff_view_ci.offset < align_props.storageTexelBufferOffsetAlignmentBytes) {
+        expectedErrors.push_back("VUID-VkBufferViewCreateInfo-buffer-02750");
+    }
+    if (buff_view_ci.offset < align_props.uniformTexelBufferOffsetAlignmentBytes) {
+        expectedErrors.push_back("VUID-VkBufferViewCreateInfo-buffer-02751");
+    }
+    CreateBufferViewTest(*this, &buff_view_ci, expectedErrors);
+    expectedErrors.clear();
+
+    buff_view_ci.offset = 4;
+    if (buff_view_ci.offset < align_props.storageTexelBufferOffsetAlignmentBytes &&
+        !align_props.storageTexelBufferOffsetSingleTexelAlignment) {
+        expectedErrors.push_back("VUID-VkBufferViewCreateInfo-buffer-02750");
+    }
+    if (buff_view_ci.offset < align_props.uniformTexelBufferOffsetAlignmentBytes &&
+        !align_props.uniformTexelBufferOffsetSingleTexelAlignment) {
+        expectedErrors.push_back("VUID-VkBufferViewCreateInfo-buffer-02751");
+    }
+    CreateBufferViewTest(*this, &buff_view_ci, expectedErrors);
+    expectedErrors.clear();
+
+    // Test a 3-component format
+    VkFormatProperties format_properties;
+    vkGetPhysicalDeviceFormatProperties(gpu(), VK_FORMAT_R32G32B32_SFLOAT, &format_properties);
+    if (format_properties.bufferFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT) {
+        buffer_info.usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
+        VkBufferObj buffer2;
+        buffer2.init(*m_device, buffer_info, (VkMemoryPropertyFlags)VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+
+        // Create a test buffer view
+        buff_view_ci.buffer = buffer2.handle();
+
+        buff_view_ci.format = VK_FORMAT_R32G32B32_SFLOAT;
+        buff_view_ci.offset = 1;
+        if (buff_view_ci.offset < align_props.uniformTexelBufferOffsetAlignmentBytes) {
+            expectedErrors.push_back("VUID-VkBufferViewCreateInfo-buffer-02751");
+        }
+        CreateBufferViewTest(*this, &buff_view_ci, expectedErrors);
+        expectedErrors.clear();
+
+        buff_view_ci.offset = 4;
+        if (buff_view_ci.offset < align_props.uniformTexelBufferOffsetAlignmentBytes &&
+            !align_props.uniformTexelBufferOffsetSingleTexelAlignment) {
+            expectedErrors.push_back("VUID-VkBufferViewCreateInfo-buffer-02751");
+        }
+        CreateBufferViewTest(*this, &buff_view_ci, expectedErrors);
+        expectedErrors.clear();
+    }
 }
 
 TEST_F(VkLayerTest, FillBufferWithinRenderPass) {
@@ -4496,9 +4510,6 @@ TEST_F(VkLayerTest, VertexBufferInvalid) {
         "Submit a command buffer using deleted vertex buffer, delete a buffer twice, use an invalid offset for each buffer type, "
         "and attempt to bind a null buffer");
 
-    const char *deleted_buffer_in_command_buffer = "UNASSIGNED-CoreValidation-DrawState-InvalidBuffer";
-    const char *invalid_offset_message = "VUID-vkBindBufferMemory-memoryOffset-01036";
-
     ASSERT_NO_FATAL_FAILURE(Init());
     ASSERT_NO_FATAL_FAILURE(InitViewport());
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
@@ -4511,23 +4522,23 @@ TEST_F(VkLayerTest, VertexBufferInvalid) {
     m_commandBuffer->begin();
     m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
     vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "CoreValidation-DrawState-InvalidCommandBuffer-VkBuffer");
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "CoreValidation-DrawState-InvalidCommandBuffer-VkDeviceMemory");
 
     {
-        // Create and bind a vertex buffer in a reduced scope, which will cause
-        // it to be deleted upon leaving this scope
+        // Create and bind a vertex buffer in a reduced scope, which will cause it to be deleted upon leaving this scope
         const float vbo_data[3] = {1.f, 0.f, 1.f};
         VkVerticesObj draw_verticies(m_device, 1, 1, sizeof(vbo_data[0]), sizeof(vbo_data) / sizeof(vbo_data[0]), vbo_data);
         draw_verticies.BindVertexBuffers(m_commandBuffer->handle());
         draw_verticies.AddVertexInputToPipeHelpr(&pipe);
-    }
 
-    m_commandBuffer->Draw(1, 0, 0, 0);
+        m_commandBuffer->Draw(1, 0, 0, 0);
 
-    m_commandBuffer->EndRenderPass();
-    m_commandBuffer->end();
+        m_commandBuffer->EndRenderPass();
+    }
 
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, deleted_buffer_in_command_buffer);
-    m_commandBuffer->QueueCommandBuffer(false);
+    vkEndCommandBuffer(m_commandBuffer->handle());
     m_errorMonitor->VerifyFound();
 
     {
@@ -4542,7 +4553,7 @@ TEST_F(VkLayerTest, VertexBufferInvalid) {
     m_errorMonitor->SetUnexpectedError("value of pCreateInfo->usage must not be 0");
     if (VkBufferTest::GetTestConditionValid(m_device, VkBufferTest::eInvalidMemoryOffset)) {
         // Create and bind a memory buffer with an invalid offset.
-        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, invalid_offset_message);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkBindBufferMemory-memoryOffset-01036");
         m_errorMonitor->SetUnexpectedError(
             "If buffer was created with the VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT or VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT, "
             "memoryOffset must be a multiple of VkPhysicalDeviceLimits::minTexelBufferOffsetAlignment");
@@ -5325,13 +5336,10 @@ TEST_F(VkLayerTest, InvalidImageViewUsageCreateInfo) {
 
     // Try a zero usage field
     usage_ci.usage = 0;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                                         "vkCreateImageView: Chained VkImageViewUsageCreateInfo usage field must not be 0");
-    CreateImageViewTest(*this, &ivci, "VkImageViewUsageCreateInfo: value of usage must not be 0");
+    CreateImageViewTest(*this, &ivci, "VUID-VkImageViewUsageCreateInfo-usage-requiredbitmask");
 
     // Try an illegal bit in usage field
     usage_ci.usage = 0x10000000 | VK_IMAGE_USAGE_SAMPLED_BIT;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "UNASSIGNED-GeneralParameterError-UnrecognizedValue");
     CreateImageViewTest(*this, &ivci, "VUID-VkImageViewUsageCreateInfo-usage-parameter");
 }
 
@@ -6050,7 +6058,23 @@ TEST_F(VkLayerTest, CreateImageMinLimitsViolation) {
 TEST_F(VkLayerTest, CreateImageMaxLimitsViolation) {
     TEST_DESCRIPTION("Create invalid image with invalid parameters exceeding physical device limits.");
 
-    ASSERT_NO_FATAL_FAILURE(Init());
+    // Check for VK_KHR_get_physical_device_properties2
+    bool push_physical_device_properties_2_support =
+        InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    if (push_physical_device_properties_2_support) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    bool push_fragment_density_support = false;
+
+    if (push_physical_device_properties_2_support) {
+        push_fragment_density_support = DeviceExtensionSupported(gpu(), nullptr, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME);
+        if (push_fragment_density_support) m_device_extension_names.push_back(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME);
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, 0));
 
     VkImageCreateInfo tmp_img_ci = {};
     tmp_img_ci.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
@@ -6143,6 +6167,23 @@ TEST_F(VkLayerTest, CreateImageMaxLimitsViolation) {
             printf("%s VkPhysicalDeviceLimits::maxFramebufferHeight is already UINT32_MAX; skipping part of test.\n", kSkipPrefix);
         }
     }
+
+    {
+        if (!push_fragment_density_support) {
+            printf("%s VK_EXT_fragment_density_map Extension not supported, skipping tests\n", kSkipPrefix);
+        } else {
+            VkImageCreateInfo image_ci = safe_image_ci;
+            image_ci.usage = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT;
+            VkImageFormatProperties img_limits;
+            ASSERT_VK_SUCCESS(GPDIFPHelper(gpu(), &image_ci, &img_limits));
+
+            image_ci.extent = {dev_limits.maxFramebufferWidth + 1, 64, 1};
+            CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-02559");
+
+            image_ci.extent = {64, dev_limits.maxFramebufferHeight + 1, 1};
+            CreateImageTest(*this, &image_ci, "VUID-VkImageCreateInfo-usage-02560");
+        }
+    }
 }
 
 TEST_F(VkLayerTest, MultiplaneImageSamplerConversionMismatch) {
diff --git a/tests/vklayertests_command.cpp b/tests/vklayertests_command.cpp
index 9ca91a8c3..3c44562bd 100644
--- a/tests/vklayertests_command.cpp
+++ b/tests/vklayertests_command.cpp
@@ -179,6 +179,49 @@ TEST_F(VkLayerTest, DynamicLineWidthNotBound) {
     m_errorMonitor->VerifyFound();
 }
 
+TEST_F(VkLayerTest, DynamicLineStippleNotBound) {
+    TEST_DESCRIPTION(
+        "Run a simple draw calls to validate failure when Line Stipple dynamic state is required but not correctly bound.");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+    std::array<const char *, 1> required_device_extensions = {{VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME}};
+    for (auto device_extension : required_device_extensions) {
+        if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
+            m_device_extension_names.push_back(device_extension);
+        } else {
+            printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
+            return;
+        }
+    }
+
+    PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
+        (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
+    ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
+
+    auto line_rasterization_features = lvl_init_struct<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
+    auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&line_rasterization_features);
+    vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
+
+    if (!line_rasterization_features.stippledBresenhamLines || !line_rasterization_features.bresenhamLines) {
+        printf("%sStipple Bresenham lines not supported; skipped.\n", kSkipPrefix);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                         "Dynamic line stipple state not set for this command buffer");
+    VKTriangleTest(BsoFailLineStipple);
+    m_errorMonitor->VerifyFound();
+}
+
 TEST_F(VkLayerTest, DynamicViewportNotBound) {
     TEST_DESCRIPTION(
         "Run a simple draw calls to validate failure when Viewport dynamic state is required but not correctly bound.");
@@ -885,7 +928,7 @@ TEST_F(VkLayerTest, NonSimultaneousSecondaryMarksPrimary) {
 TEST_F(VkLayerTest, SimultaneousUseSecondaryTwoExecutes) {
     ASSERT_NO_FATAL_FAILURE(Init());
 
-    const char *simultaneous_use_message = "without VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set!";
+    const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00092";
 
     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
 
@@ -912,7 +955,7 @@ TEST_F(VkLayerTest, SimultaneousUseSecondarySingleExecute) {
     // variation on previous test executing the same CB twice in the same
     // CmdExecuteCommands call
 
-    const char *simultaneous_use_message = "without VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT set!";
+    const char *simultaneous_use_message = "VUID-vkCmdExecuteCommands-pCommandBuffers-00093";
 
     VkCommandBufferObj secondary(m_device, m_commandPool, VK_COMMAND_BUFFER_LEVEL_SECONDARY);
 
@@ -3845,11 +3888,6 @@ TEST_F(VkLayerTest, SetDynViewportParamTests) {
     m_errorMonitor->VerifyFound();
 
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01224");
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-arraylength");
-    vkCmdSetViewport(m_commandBuffer->handle(), 1, 0, viewports);
-    m_errorMonitor->VerifyFound();
-
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01224");
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-01225");
     vkCmdSetViewport(m_commandBuffer->handle(), 1, 2, viewports);
     m_errorMonitor->VerifyFound();
@@ -3975,8 +4013,7 @@ TEST_F(VkLayerTest, SetDynViewportParamMultiviewportTests) {
     m_errorMonitor->VerifyFound();
 
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-viewportCount-arraylength");
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetViewport-firstViewport-01223");
-    vkCmdSetViewport(m_commandBuffer->handle(), max_viewports + 1, 0, viewports.data());
+    vkCmdSetViewport(m_commandBuffer->handle(), 1, 0, viewports.data());
     m_errorMonitor->VerifyFound();
 }
 
@@ -4233,11 +4270,6 @@ TEST_F(VkLayerTest, SetDynScissorParamTests) {
     m_errorMonitor->VerifyFound();
 
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00593");
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-arraylength");
-    vkCmdSetScissor(m_commandBuffer->handle(), 1, 0, scissors);
-    m_errorMonitor->VerifyFound();
-
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00593");
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-00594");
     vkCmdSetScissor(m_commandBuffer->handle(), 1, 2, scissors);
     m_errorMonitor->VerifyFound();
@@ -4317,8 +4349,7 @@ TEST_F(VkLayerTest, SetDynScissorParamMultiviewportTests) {
     m_errorMonitor->VerifyFound();
 
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-scissorCount-arraylength");
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetScissor-firstScissor-00592");
-    vkCmdSetScissor(m_commandBuffer->handle(), max_scissors + 1, 0, scissors.data());
+    vkCmdSetScissor(m_commandBuffer->handle(), 1, 0, scissors.data());
     m_errorMonitor->VerifyFound();
 }
 
diff --git a/tests/vklayertests_descriptor_renderpass_framebuffer.cpp b/tests/vklayertests_descriptor_renderpass_framebuffer.cpp
index ffaebebdf..c765ea411 100644
--- a/tests/vklayertests_descriptor_renderpass_framebuffer.cpp
+++ b/tests/vklayertests_descriptor_renderpass_framebuffer.cpp
@@ -27,7 +27,7 @@
 #include "cast_utils.h"
 #include "layer_validation_tests.h"
 
-TEST_F(VkLayerTest, GpuValidationArrayOOB) {
+TEST_F(VkLayerTest, GpuValidationArrayOOBGraphicsShaders) {
     TEST_DESCRIPTION(
         "GPU validation: Verify detection of out-of-bounds descriptor array indexing and use of uninitialized descriptors.");
     if (!VkRenderFramework::DeviceCanDraw()) {
@@ -286,9 +286,34 @@ TEST_F(VkLayerTest, GpuValidationArrayOOB) {
         "void main(){\n"
         "   uFragColor = colors[index].val;\n"
         "}\n";
+    char const *gsSource =
+        "#version 450\n"
+        "#extension GL_EXT_nonuniform_qualifier : enable\n "
+        "layout(triangles) in;\n"
+        "layout(triangle_strip, max_vertices=3) out;\n"
+        "layout(location=0) in VertexData { vec4 x; } gs_in[];\n"
+        "layout(std140, set = 0, binding = 0) uniform ufoo { uint index; } uniform_index_buffer;\n"
+        "layout(set = 0, binding = 1) buffer bfoo { vec4 val; } adds[];\n"
+        "void main() {\n"
+        "   gl_Position = gs_in[0].x + adds[uniform_index_buffer.index].val.x;\n"
+        "   EmitVertex();\n"
+        "}\n";
+    static const char *tesSource =
+        "#version 450\n"
+        "#extension GL_EXT_nonuniform_qualifier : enable\n "
+        "layout(std140, set = 0, binding = 0) uniform ufoo { uint index; } uniform_index_buffer;\n"
+        "layout(set = 0, binding = 1) buffer bfoo { vec4 val; } adds[];\n"
+        "layout(triangles, equal_spacing, cw) in;\n"
+        "void main() {\n"
+        "    gl_Position = adds[uniform_index_buffer.index].val;\n"
+        "}\n";
+
     struct TestCase {
         char const *vertex_source;
         char const *fragment_source;
+        char const *geometry_source;
+        char const *tess_ctrl_source;
+        char const *tess_eval_source;
         bool debug;
         const VkPipelineLayoutObj *pipeline_layout;
         const OneOffDescriptorSet *descriptor_set;
@@ -297,33 +322,47 @@ TEST_F(VkLayerTest, GpuValidationArrayOOB) {
     };
 
     std::vector<TestCase> tests;
-    tests.push_back({vsSource_vert, fsSource_vert, false, &pipeline_layout, &descriptor_set, 25,
+    tests.push_back({vsSource_vert, fsSource_vert, nullptr, nullptr, nullptr, false, &pipeline_layout, &descriptor_set, 25,
                      "Index of 25 used to index descriptor array of length 6."});
-    tests.push_back({vsSource_frag, fsSource_frag, false, &pipeline_layout, &descriptor_set, 25,
+    tests.push_back({vsSource_frag, fsSource_frag, nullptr, nullptr, nullptr, false, &pipeline_layout, &descriptor_set, 25,
                      "Index of 25 used to index descriptor array of length 6."});
 #if !defined(ANDROID)
     // The Android test framework uses shaderc for online compilations.  Even when configured to compile with debug info,
     // shaderc seems to drop the OpLine instructions from the shader binary.  This causes the following two tests to fail
     // on Android platforms.  Skip these tests until the shaderc issue is understood/resolved.
-    tests.push_back({vsSource_vert, fsSource_vert, true, &pipeline_layout, &descriptor_set, 25,
+    tests.push_back({vsSource_vert, fsSource_vert, nullptr, nullptr, nullptr, true, &pipeline_layout, &descriptor_set, 25,
                      "gl_Position += 1e-30 * texture(tex[uniform_index_buffer.tex_index[0]], vec2(0, 0));"});
-    tests.push_back({vsSource_frag, fsSource_frag, true, &pipeline_layout, &descriptor_set, 25,
+    tests.push_back({vsSource_frag, fsSource_frag, nullptr, nullptr, nullptr, true, &pipeline_layout, &descriptor_set, 25,
                      "uFragColor = texture(tex[index], vec2(0, 0));"});
 #endif
     if (descriptor_indexing) {
-        tests.push_back({vsSource_frag, fsSource_frag_runtime, false, &pipeline_layout, &descriptor_set, 25,
-                         "Index of 25 used to index descriptor array of length 6."});
-        tests.push_back({vsSource_frag, fsSource_frag_runtime, false, &pipeline_layout, &descriptor_set, 5,
-                         "Descriptor index 5 is uninitialized"});
+        tests.push_back({vsSource_frag, fsSource_frag_runtime, nullptr, nullptr, nullptr, false, &pipeline_layout, &descriptor_set,
+                         25, "Index of 25 used to index descriptor array of length 6."});
+        tests.push_back({vsSource_frag, fsSource_frag_runtime, nullptr, nullptr, nullptr, false, &pipeline_layout, &descriptor_set,
+                         5, "Descriptor index 5 is uninitialized"});
         // Pick 6 below because it is less than the maximum specified, but more than the actual specified
-        tests.push_back({vsSource_frag, fsSource_frag_runtime, false, &pipeline_layout_variable, &descriptor_set_variable, 6,
-                         "Index of 6 used to index descriptor array of length 6."});
-        tests.push_back({vsSource_frag, fsSource_frag_runtime, false, &pipeline_layout_variable, &descriptor_set_variable, 5,
-                         "Descriptor index 5 is uninitialized"});
-        tests.push_back({vsSource_frag, fsSource_buffer, false, &pipeline_layout_buffer, &descriptor_set_buffer, 25,
-                         "Index of 25 used to index descriptor array of length 6."});
-        tests.push_back({vsSource_frag, fsSource_buffer, false, &pipeline_layout_buffer, &descriptor_set_buffer, 5,
-                         "Descriptor index 5 is uninitialized"});
+        tests.push_back({vsSource_frag, fsSource_frag_runtime, nullptr, nullptr, nullptr, false, &pipeline_layout_variable,
+                         &descriptor_set_variable, 6, "Index of 6 used to index descriptor array of length 6."});
+        tests.push_back({vsSource_frag, fsSource_frag_runtime, nullptr, nullptr, nullptr, false, &pipeline_layout_variable,
+                         &descriptor_set_variable, 5, "Descriptor index 5 is uninitialized"});
+        tests.push_back({vsSource_frag, fsSource_buffer, nullptr, nullptr, nullptr, false, &pipeline_layout_buffer,
+                         &descriptor_set_buffer, 25, "Index of 25 used to index descriptor array of length 6."});
+        tests.push_back({vsSource_frag, fsSource_buffer, nullptr, nullptr, nullptr, false, &pipeline_layout_buffer,
+                         &descriptor_set_buffer, 5, "Descriptor index 5 is uninitialized"});
+        if (m_device->phy().features().geometryShader) {
+            // OOB Geometry
+            tests.push_back({bindStateVertShaderText, bindStateFragShaderText, gsSource, nullptr, nullptr, false,
+                             &pipeline_layout_buffer, &descriptor_set_buffer, 25, "Stage = Geometry"});
+            // Uninitialized Geometry
+            tests.push_back({bindStateVertShaderText, bindStateFragShaderText, gsSource, nullptr, nullptr, false,
+                             &pipeline_layout_buffer, &descriptor_set_buffer, 5, "Stage = Geometry"});
+        }
+        if (m_device->phy().features().tessellationShader) {
+            tests.push_back({bindStateVertShaderText, bindStateFragShaderText, nullptr, bindStateTscShaderText, tesSource, false,
+                             &pipeline_layout_buffer, &descriptor_set_buffer, 25, "Stage = Tessellation Eval"});
+            tests.push_back({bindStateVertShaderText, bindStateFragShaderText, nullptr, bindStateTscShaderText, tesSource, false,
+                             &pipeline_layout_buffer, &descriptor_set_buffer, 5, "Stage = Tessellation Eval"});
+        }
     }
 
     VkViewport viewport = m_viewports[0];
@@ -339,9 +378,34 @@ TEST_F(VkLayerTest, GpuValidationArrayOOB) {
         m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, iter.expected_error);
         VkShaderObj vs(m_device, iter.vertex_source, VK_SHADER_STAGE_VERTEX_BIT, this, "main", iter.debug);
         VkShaderObj fs(m_device, iter.fragment_source, VK_SHADER_STAGE_FRAGMENT_BIT, this, "main", iter.debug);
+        VkShaderObj *gs = nullptr;
+        VkShaderObj *tcs = nullptr;
+        VkShaderObj *tes = nullptr;
         VkPipelineObj pipe(m_device);
         pipe.AddShader(&vs);
         pipe.AddShader(&fs);
+        if (iter.geometry_source) {
+            gs = new VkShaderObj(m_device, iter.geometry_source, VK_SHADER_STAGE_GEOMETRY_BIT, this, "main", iter.debug);
+            pipe.AddShader(gs);
+        }
+        if (iter.tess_ctrl_source && iter.tess_eval_source) {
+            tcs = new VkShaderObj(m_device, iter.tess_ctrl_source, VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, this, "main",
+                                  iter.debug);
+            tes = new VkShaderObj(m_device, iter.tess_eval_source, VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, this, "main",
+                                  iter.debug);
+            pipe.AddShader(tcs);
+            pipe.AddShader(tes);
+            VkPipelineInputAssemblyStateCreateInfo iasci{VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, nullptr, 0,
+                                                         VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, VK_FALSE};
+            VkPipelineTessellationDomainOriginStateCreateInfo tessellationDomainOriginStateInfo = {
+                VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, VK_NULL_HANDLE,
+                VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT};
+
+            VkPipelineTessellationStateCreateInfo tsci{VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
+                                                       &tessellationDomainOriginStateInfo, 0, 3};
+            pipe.SetTessellation(&tsci);
+            pipe.SetInputAssembly(&iasci);
+        }
         pipe.AddDefaultColorAttachment();
         err = pipe.CreateVKPipeline(iter.pipeline_layout->handle(), renderPass());
         ASSERT_VK_SUCCESS(err);
@@ -361,9 +425,931 @@ TEST_F(VkLayerTest, GpuValidationArrayOOB) {
         vkQueueSubmit(m_device->m_queue, 1, &submit_info, VK_NULL_HANDLE);
         vkQueueWaitIdle(m_device->m_queue);
         m_errorMonitor->VerifyFound();
+        if (gs) {
+            delete gs;
+        }
+        if (tcs && tes) {
+            delete tcs;
+            delete tes;
+        }
+    }
+    auto c_queue = m_device->GetDefaultComputeQueue();
+    if (c_queue && descriptor_indexing) {
+        char const *csSource =
+            "#version 450\n"
+            "#extension GL_EXT_nonuniform_qualifier : enable\n "
+            "layout(set = 0, binding = 0) uniform ufoo { uint index; } u_index;"
+            "layout(set = 0, binding = 1) buffer StorageBuffer {\n"
+            "    uint data;\n"
+            "} Data[];\n"
+            "void main() {\n"
+            "   Data[(u_index.index - 1)].data = Data[u_index.index].data;\n"
+            "}\n";
+
+        auto shader_module = new VkShaderObj(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
+
+        VkPipelineShaderStageCreateInfo stage;
+        stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        stage.pNext = nullptr;
+        stage.flags = 0;
+        stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
+        stage.module = shader_module->handle();
+        stage.pName = "main";
+        stage.pSpecializationInfo = nullptr;
+
+        // CreateComputePipelines
+        VkComputePipelineCreateInfo pipeline_info = {};
+        pipeline_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+        pipeline_info.pNext = nullptr;
+        pipeline_info.flags = 0;
+        pipeline_info.layout = pipeline_layout_buffer.handle();
+        pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
+        pipeline_info.basePipelineIndex = -1;
+        pipeline_info.stage = stage;
+
+        VkPipeline c_pipeline;
+        vkCreateComputePipelines(device(), VK_NULL_HANDLE, 1, &pipeline_info, nullptr, &c_pipeline);
+        VkCommandBufferBeginInfo begin_info = {};
+        VkCommandBufferInheritanceInfo hinfo = {};
+        hinfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
+        begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
+        begin_info.pInheritanceInfo = &hinfo;
+
+        m_commandBuffer->begin(&begin_info);
+        vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_COMPUTE, c_pipeline);
+        vkCmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_layout_buffer.handle(), 0, 1,
+                                &descriptor_set_buffer.set_, 0, nullptr);
+        vkCmdDispatch(m_commandBuffer->handle(), 1, 1, 1);
+        m_commandBuffer->end();
+
+        // Uninitialized
+        uint32_t *data = (uint32_t *)buffer0.memory().map();
+        data[0] = 5;
+        buffer0.memory().unmap();
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Stage = Compute");
+        vkQueueSubmit(c_queue->handle(), 1, &submit_info, VK_NULL_HANDLE);
+        vkQueueWaitIdle(m_device->m_queue);
+        m_errorMonitor->VerifyFound();
+        // Out of Bounds
+        data = (uint32_t *)buffer0.memory().map();
+        data[0] = 25;
+        buffer0.memory().unmap();
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "Stage = Compute");
+        vkQueueSubmit(c_queue->handle(), 1, &submit_info, VK_NULL_HANDLE);
+        vkQueueWaitIdle(m_device->m_queue);
+        m_errorMonitor->VerifyFound();
+        vkDestroyPipeline(m_device->handle(), c_pipeline, NULL);
+        vkDestroyShaderModule(m_device->handle(), shader_module->handle(), NULL);
     }
     return;
 }
+
+TEST_F(VkLayerTest, GpuValidationArrayOOBRayTracingShaders) {
+    TEST_DESCRIPTION(
+        "GPU validation: Verify detection of out-of-bounds descriptor array indexing and use of uninitialized descriptors for "
+        "ray tracing shaders.");
+
+    std::array<const char *, 1> required_instance_extensions = {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME};
+    for (auto instance_extension : required_instance_extensions) {
+        if (InstanceExtensionSupported(instance_extension)) {
+            m_instance_extension_names.push_back(instance_extension);
+        } else {
+            printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix, instance_extension);
+            return;
+        }
+    }
+
+    VkValidationFeatureEnableEXT validation_feature_enables[] = {VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT};
+    VkValidationFeaturesEXT validation_features = {};
+    validation_features.sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
+    validation_features.enabledValidationFeatureCount = 1;
+    validation_features.pEnabledValidationFeatures = validation_feature_enables;
+    bool descriptor_indexing = CheckDescriptorIndexingSupportAndInitFramework(
+        this, m_instance_extension_names, m_device_extension_names, &validation_features, m_errorMonitor);
+
+    if (DeviceIsMockICD() || DeviceSimulation()) {
+        printf("%s Test not supported by MockICD, skipping tests\n", kSkipPrefix);
+        return;
+    }
+
+    std::array<const char *, 2> required_device_extensions = {VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
+                                                              VK_NV_RAY_TRACING_EXTENSION_NAME};
+    for (auto device_extension : required_device_extensions) {
+        if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
+            m_device_extension_names.push_back(device_extension);
+        } else {
+            printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
+            return;
+        }
+    }
+
+    VkPhysicalDeviceFeatures2KHR features2 = {};
+    auto indexing_features = lvl_init_struct<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>();
+    if (descriptor_indexing) {
+        PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
+            (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
+        ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
+
+        features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&indexing_features);
+        vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
+
+        if (!indexing_features.runtimeDescriptorArray || !indexing_features.descriptorBindingPartiallyBound ||
+            !indexing_features.descriptorBindingSampledImageUpdateAfterBind ||
+            !indexing_features.descriptorBindingVariableDescriptorCount) {
+            printf("Not all descriptor indexing features supported, skipping descriptor indexing tests\n");
+            descriptor_indexing = false;
+        }
+    }
+    VkCommandPoolCreateFlags pool_flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, pool_flags));
+
+    PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR =
+        (PFN_vkGetPhysicalDeviceProperties2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceProperties2KHR");
+    ASSERT_TRUE(vkGetPhysicalDeviceProperties2KHR != nullptr);
+
+    auto ray_tracing_properties = lvl_init_struct<VkPhysicalDeviceRayTracingPropertiesNV>();
+    auto properties2 = lvl_init_struct<VkPhysicalDeviceProperties2KHR>(&ray_tracing_properties);
+    vkGetPhysicalDeviceProperties2KHR(gpu(), &properties2);
+    if (ray_tracing_properties.maxTriangleCount == 0) {
+        printf("%s Did not find required ray tracing properties; skipped.\n", kSkipPrefix);
+        return;
+    }
+
+    VkQueue ray_tracing_queue = m_device->m_queue;
+    uint32_t ray_tracing_queue_family_index = 0;
+
+    // If supported, run on the compute only queue.
+    uint32_t compute_only_queue_family_index = m_device->QueueFamilyMatching(VK_QUEUE_COMPUTE_BIT, VK_QUEUE_GRAPHICS_BIT);
+    if (compute_only_queue_family_index != UINT32_MAX) {
+        const auto &compute_only_queues = m_device->queue_family_queues(compute_only_queue_family_index);
+        if (!compute_only_queues.empty()) {
+            ray_tracing_queue = compute_only_queues[0]->handle();
+            ray_tracing_queue_family_index = compute_only_queue_family_index;
+        }
+    }
+
+    VkCommandPoolObj ray_tracing_command_pool(m_device, ray_tracing_queue_family_index,
+                                              VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT);
+    VkCommandBufferObj ray_tracing_command_buffer(m_device, &ray_tracing_command_pool);
+
+    struct AABB {
+        float min_x;
+        float min_y;
+        float min_z;
+        float max_x;
+        float max_y;
+        float max_z;
+    };
+
+    const std::vector<AABB> aabbs = {{-1.0f, -1.0f, -1.0f, +1.0f, +1.0f, +1.0f}};
+
+    struct VkGeometryInstanceNV {
+        float transform[12];
+        uint32_t instanceCustomIndex : 24;
+        uint32_t mask : 8;
+        uint32_t instanceOffset : 24;
+        uint32_t flags : 8;
+        uint64_t accelerationStructureHandle;
+    };
+
+    VkDeviceSize aabb_buffer_size = sizeof(AABB) * aabbs.size();
+    VkBufferObj aabb_buffer;
+    aabb_buffer.init(*m_device, aabb_buffer_size, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, {ray_tracing_queue_family_index});
+
+    uint8_t *mapped_aabb_buffer_data = (uint8_t *)aabb_buffer.memory().map();
+    std::memcpy(mapped_aabb_buffer_data, (uint8_t *)aabbs.data(), static_cast<std::size_t>(aabb_buffer_size));
+    aabb_buffer.memory().unmap();
+
+    VkGeometryNV geometry = {};
+    geometry.sType = VK_STRUCTURE_TYPE_GEOMETRY_NV;
+    geometry.geometryType = VK_GEOMETRY_TYPE_AABBS_NV;
+    geometry.geometry.triangles = {};
+    geometry.geometry.triangles.sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV;
+    geometry.geometry.aabbs = {};
+    geometry.geometry.aabbs.sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV;
+    geometry.geometry.aabbs.aabbData = aabb_buffer.handle();
+    geometry.geometry.aabbs.numAABBs = static_cast<uint32_t>(aabbs.size());
+    geometry.geometry.aabbs.offset = 0;
+    geometry.geometry.aabbs.stride = static_cast<VkDeviceSize>(sizeof(AABB));
+    geometry.flags = 0;
+
+    VkAccelerationStructureInfoNV bot_level_as_info = {};
+    bot_level_as_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV;
+    bot_level_as_info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
+    bot_level_as_info.instanceCount = 0;
+    bot_level_as_info.geometryCount = 1;
+    bot_level_as_info.pGeometries = &geometry;
+
+    VkAccelerationStructureCreateInfoNV bot_level_as_create_info = {};
+    bot_level_as_create_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+    bot_level_as_create_info.info = bot_level_as_info;
+
+    VkAccelerationStructureObj bot_level_as(*m_device, bot_level_as_create_info);
+
+    const std::vector<VkGeometryInstanceNV> instances = {
+        VkGeometryInstanceNV{
+            {
+                // clang-format off
+                1.0f, 0.0f, 0.0f, 0.0f,
+                0.0f, 1.0f, 0.0f, 0.0f,
+                0.0f, 0.0f, 1.0f, 0.0f,
+                // clang-format on
+            },
+            0,
+            0xFF,
+            0,
+            VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV,
+            bot_level_as.opaque_handle(),
+        },
+    };
+
+    VkDeviceSize instance_buffer_size = sizeof(VkGeometryInstanceNV) * instances.size();
+    VkBufferObj instance_buffer;
+    instance_buffer.init(*m_device, instance_buffer_size,
+                         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                         VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, {ray_tracing_queue_family_index});
+
+    uint8_t *mapped_instance_buffer_data = (uint8_t *)instance_buffer.memory().map();
+    std::memcpy(mapped_instance_buffer_data, (uint8_t *)instances.data(), static_cast<std::size_t>(instance_buffer_size));
+    instance_buffer.memory().unmap();
+
+    VkAccelerationStructureInfoNV top_level_as_info = {};
+    top_level_as_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV;
+    top_level_as_info.type = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV;
+    top_level_as_info.instanceCount = 1;
+    top_level_as_info.geometryCount = 0;
+
+    VkAccelerationStructureCreateInfoNV top_level_as_create_info = {};
+    top_level_as_create_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+    top_level_as_create_info.info = top_level_as_info;
+
+    VkAccelerationStructureObj top_level_as(*m_device, top_level_as_create_info);
+
+    VkDeviceSize scratch_buffer_size = std::max(bot_level_as.build_scratch_memory_requirements().memoryRequirements.size,
+                                                top_level_as.build_scratch_memory_requirements().memoryRequirements.size);
+    VkBufferObj scratch_buffer;
+    scratch_buffer.init(*m_device, scratch_buffer_size, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_BUFFER_USAGE_RAY_TRACING_BIT_NV);
+
+    ray_tracing_command_buffer.begin();
+
+    // Build bot level acceleration structure
+    ray_tracing_command_buffer.BuildAccelerationStructure(&bot_level_as, scratch_buffer.handle());
+
+    // Barrier to prevent using scratch buffer for top level build before bottom level build finishes
+    VkMemoryBarrier memory_barrier = {};
+    memory_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
+    memory_barrier.srcAccessMask = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV | VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV;
+    memory_barrier.dstAccessMask = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV | VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV;
+    ray_tracing_command_buffer.PipelineBarrier(VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV,
+                                               VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV, 0, 1, &memory_barrier, 0,
+                                               nullptr, 0, nullptr);
+
+    // Build top level acceleration structure
+    ray_tracing_command_buffer.BuildAccelerationStructure(&top_level_as, scratch_buffer.handle(), instance_buffer.handle());
+
+    ray_tracing_command_buffer.end();
+
+    VkSubmitInfo submit_info = {};
+    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submit_info.commandBufferCount = 1;
+    submit_info.pCommandBuffers = &ray_tracing_command_buffer.handle();
+    vkQueueSubmit(ray_tracing_queue, 1, &submit_info, VK_NULL_HANDLE);
+    vkQueueWaitIdle(ray_tracing_queue);
+    m_errorMonitor->VerifyNotFound();
+
+    VkTextureObj texture(m_device, nullptr);
+    VkSamplerObj sampler(m_device);
+
+    VkDeviceSize storage_buffer_size = 1024;
+    VkBufferObj storage_buffer;
+    storage_buffer.init(*m_device, storage_buffer_size, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                        VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, {ray_tracing_queue_family_index});
+
+    VkDeviceSize shader_binding_table_buffer_size = ray_tracing_properties.shaderGroupHandleSize * 4ull;
+    VkBufferObj shader_binding_table_buffer;
+    shader_binding_table_buffer.init(*m_device, shader_binding_table_buffer_size,
+                                     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                                     VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, {ray_tracing_queue_family_index});
+
+    // Setup descriptors!
+    const VkShaderStageFlags kAllRayTracingStages = VK_SHADER_STAGE_RAYGEN_BIT_NV | VK_SHADER_STAGE_ANY_HIT_BIT_NV |
+                                                    VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV | VK_SHADER_STAGE_MISS_BIT_NV |
+                                                    VK_SHADER_STAGE_INTERSECTION_BIT_NV | VK_SHADER_STAGE_CALLABLE_BIT_NV;
+
+    void *layout_pnext = nullptr;
+    void *allocate_pnext = nullptr;
+    VkDescriptorPoolCreateFlags pool_create_flags = 0;
+    VkDescriptorSetLayoutCreateFlags layout_create_flags = 0;
+    VkDescriptorBindingFlagsEXT ds_binding_flags[3] = {};
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT layout_createinfo_binding_flags[1] = {};
+    if (descriptor_indexing) {
+        ds_binding_flags[0] = 0;
+        ds_binding_flags[1] = 0;
+        ds_binding_flags[2] = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT;
+
+        layout_createinfo_binding_flags[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT;
+        layout_createinfo_binding_flags[0].pNext = NULL;
+        layout_createinfo_binding_flags[0].bindingCount = 3;
+        layout_createinfo_binding_flags[0].pBindingFlags = ds_binding_flags;
+        layout_create_flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT;
+        pool_create_flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT;
+        layout_pnext = layout_createinfo_binding_flags;
+    }
+
+    // Prepare descriptors
+    OneOffDescriptorSet ds(m_device,
+                           {
+                               {0, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, 1, kAllRayTracingStages, nullptr},
+                               {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, kAllRayTracingStages, nullptr},
+                               {2, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 6, kAllRayTracingStages, nullptr},
+                           },
+                           layout_create_flags, layout_pnext, pool_create_flags);
+
+    VkDescriptorSetVariableDescriptorCountAllocateInfoEXT variable_count = {};
+    uint32_t desc_counts;
+    if (descriptor_indexing) {
+        layout_create_flags = 0;
+        pool_create_flags = 0;
+        ds_binding_flags[2] =
+            VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT;
+        desc_counts = 6;  // We'll reserve 8 spaces in the layout, but the descriptor will only use 6
+        variable_count.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT;
+        variable_count.descriptorSetCount = 1;
+        variable_count.pDescriptorCounts = &desc_counts;
+        allocate_pnext = &variable_count;
+    }
+
+    OneOffDescriptorSet ds_variable(m_device,
+                                    {
+                                        {0, VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV, 1, kAllRayTracingStages, nullptr},
+                                        {1, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, kAllRayTracingStages, nullptr},
+                                        {2, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 8, kAllRayTracingStages, nullptr},
+                                    },
+                                    layout_create_flags, layout_pnext, pool_create_flags, allocate_pnext);
+
+    VkAccelerationStructureNV top_level_as_handle = top_level_as.handle();
+    VkWriteDescriptorSetAccelerationStructureNV write_descript_set_as = {};
+    write_descript_set_as.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV;
+    write_descript_set_as.accelerationStructureCount = 1;
+    write_descript_set_as.pAccelerationStructures = &top_level_as_handle;
+
+    VkDescriptorBufferInfo descriptor_buffer_info = {};
+    descriptor_buffer_info.buffer = storage_buffer.handle();
+    descriptor_buffer_info.offset = 0;
+    descriptor_buffer_info.range = storage_buffer_size;
+
+    VkDescriptorImageInfo descriptor_image_infos[6] = {};
+    for (int i = 0; i < 6; i++) {
+        descriptor_image_infos[i] = texture.DescriptorImageInfo();
+        descriptor_image_infos[i].sampler = sampler.handle();
+        descriptor_image_infos[i].imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+    }
+
+    VkWriteDescriptorSet descriptor_writes[3] = {};
+    descriptor_writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptor_writes[0].dstSet = ds.set_;
+    descriptor_writes[0].dstBinding = 0;
+    descriptor_writes[0].descriptorCount = 1;
+    descriptor_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV;
+    descriptor_writes[0].pNext = &write_descript_set_as;
+
+    descriptor_writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptor_writes[1].dstSet = ds.set_;
+    descriptor_writes[1].dstBinding = 1;
+    descriptor_writes[1].descriptorCount = 1;
+    descriptor_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+    descriptor_writes[1].pBufferInfo = &descriptor_buffer_info;
+
+    descriptor_writes[2].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptor_writes[2].dstSet = ds.set_;
+    descriptor_writes[2].dstBinding = 2;
+    if (descriptor_indexing) {
+        descriptor_writes[2].descriptorCount = 5;  // Intentionally don't write index 5
+    } else {
+        descriptor_writes[2].descriptorCount = 6;
+    }
+    descriptor_writes[2].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
+    descriptor_writes[2].pImageInfo = descriptor_image_infos;
+    vkUpdateDescriptorSets(m_device->device(), 3, descriptor_writes, 0, NULL);
+    if (descriptor_indexing) {
+        descriptor_writes[0].dstSet = ds_variable.set_;
+        descriptor_writes[1].dstSet = ds_variable.set_;
+        descriptor_writes[2].dstSet = ds_variable.set_;
+        vkUpdateDescriptorSets(m_device->device(), 3, descriptor_writes, 0, NULL);
+    }
+
+    const VkPipelineLayoutObj pipeline_layout(m_device, {&ds.layout_});
+    const VkPipelineLayoutObj pipeline_layout_variable(m_device, {&ds_variable.layout_});
+
+    const auto SetImagesArrayLength = [](const std::string &shader_template, const std::string &length_str) {
+        const std::string to_replace = "IMAGES_ARRAY_LENGTH";
+
+        std::string result = shader_template;
+        auto position = result.find(to_replace);
+        assert(position != std::string::npos);
+        result.replace(position, to_replace.length(), length_str);
+        return result;
+    };
+
+    const std::string rgen_source_template = R"(#version 460
+        #extension GL_EXT_nonuniform_qualifier : require
+        #extension GL_EXT_samplerless_texture_functions : require
+        #extension GL_NV_ray_tracing : require
+
+        layout(set = 0, binding = 0) uniform accelerationStructureNV topLevelAS;
+        layout(set = 0, binding = 1, std430) buffer RayTracingSbo {
+	        uint rgen_index;
+	        uint ahit_index;
+	        uint chit_index;
+	        uint miss_index;
+	        uint intr_index;
+	        uint call_index;
+
+	        uint rgen_ran;
+	        uint ahit_ran;
+	        uint chit_ran;
+	        uint miss_ran;
+	        uint intr_ran;
+	        uint call_ran;
+
+	        float result1;
+	        float result2;
+	        float result3;
+        } sbo;
+        layout(set = 0, binding = 2) uniform texture2D textures[IMAGES_ARRAY_LENGTH];
+
+        layout(location = 0) rayPayloadNV vec3 payload;
+        layout(location = 3) callableDataNV vec3 callableData;
+
+        void main() {
+            sbo.rgen_ran = 1;
+
+	        executeCallableNV(0, 3);
+	        sbo.result1 = callableData.x;
+
+	        vec3 origin = vec3(0.0f, 0.0f, -2.0f);
+	        vec3 direction = vec3(0.0f, 0.0f, 1.0f);
+
+	        traceNV(topLevelAS, gl_RayFlagsNoneNV, 0xFF, 0, 1, 0, origin, 0.001, direction, 10000.0, 0);
+	        sbo.result2 = payload.x;
+
+	        traceNV(topLevelAS, gl_RayFlagsNoneNV, 0xFF, 0, 1, 0, origin, 0.001, -direction, 10000.0, 0);
+	        sbo.result3 = payload.x;
+
+            if (sbo.rgen_index > 0) {
+                // OOB here:
+                sbo.result3 = texelFetch(textures[sbo.rgen_index], ivec2(0, 0), 0).x;
+            }
+        }
+        )";
+
+    const std::string rgen_source = SetImagesArrayLength(rgen_source_template, "6");
+    const std::string rgen_source_runtime = SetImagesArrayLength(rgen_source_template, "");
+
+    const std::string ahit_source_template = R"(#version 460
+        #extension GL_EXT_nonuniform_qualifier : require
+        #extension GL_EXT_samplerless_texture_functions : require
+        #extension GL_NV_ray_tracing : require
+
+        layout(set = 0, binding = 1, std430) buffer StorageBuffer {
+	        uint rgen_index;
+	        uint ahit_index;
+	        uint chit_index;
+	        uint miss_index;
+	        uint intr_index;
+	        uint call_index;
+
+	        uint rgen_ran;
+	        uint ahit_ran;
+	        uint chit_ran;
+	        uint miss_ran;
+	        uint intr_ran;
+	        uint call_ran;
+
+	        float result1;
+	        float result2;
+	        float result3;
+        } sbo;
+        layout(set = 0, binding = 2) uniform texture2D textures[IMAGES_ARRAY_LENGTH];
+
+        hitAttributeNV vec3 hitValue;
+
+        layout(location = 0) rayPayloadInNV vec3 payload;
+
+        void main() {
+	        sbo.ahit_ran = 2;
+
+	        payload = vec3(0.1234f);
+
+            if (sbo.ahit_index > 0) {
+                // OOB here:
+                payload.x = texelFetch(textures[sbo.ahit_index], ivec2(0, 0), 0).x;
+            }
+        }
+    )";
+    const std::string ahit_source = SetImagesArrayLength(ahit_source_template, "6");
+    const std::string ahit_source_runtime = SetImagesArrayLength(ahit_source_template, "");
+
+    const std::string chit_source_template = R"(#version 460
+        #extension GL_EXT_nonuniform_qualifier : require
+        #extension GL_EXT_samplerless_texture_functions : require
+        #extension GL_NV_ray_tracing : require
+
+        layout(set = 0, binding = 1, std430) buffer RayTracingSbo {
+	        uint rgen_index;
+	        uint ahit_index;
+	        uint chit_index;
+	        uint miss_index;
+	        uint intr_index;
+	        uint call_index;
+
+	        uint rgen_ran;
+	        uint ahit_ran;
+	        uint chit_ran;
+	        uint miss_ran;
+	        uint intr_ran;
+	        uint call_ran;
+
+	        float result1;
+	        float result2;
+	        float result3;
+        } sbo;
+        layout(set = 0, binding = 2) uniform texture2D textures[IMAGES_ARRAY_LENGTH];
+
+        layout(location = 0) rayPayloadInNV vec3 payload;
+
+        hitAttributeNV vec3 attribs;
+
+        void main() {
+            sbo.chit_ran = 3;
+
+            payload = attribs;
+            if (sbo.chit_index > 0) {
+                // OOB here:
+                payload.x = texelFetch(textures[sbo.chit_index], ivec2(0, 0), 0).x;
+            }
+        }
+        )";
+    const std::string chit_source = SetImagesArrayLength(chit_source_template, "6");
+    const std::string chit_source_runtime = SetImagesArrayLength(chit_source_template, "");
+
+    const std::string miss_source_template = R"(#version 460
+        #extension GL_EXT_nonuniform_qualifier : enable
+        #extension GL_EXT_samplerless_texture_functions : require
+        #extension GL_NV_ray_tracing : require
+
+        layout(set = 0, binding = 1, std430) buffer RayTracingSbo {
+	        uint rgen_index;
+	        uint ahit_index;
+	        uint chit_index;
+	        uint miss_index;
+	        uint intr_index;
+	        uint call_index;
+
+	        uint rgen_ran;
+	        uint ahit_ran;
+	        uint chit_ran;
+	        uint miss_ran;
+	        uint intr_ran;
+	        uint call_ran;
+
+	        float result1;
+	        float result2;
+	        float result3;
+        } sbo;
+        layout(set = 0, binding = 2) uniform texture2D textures[IMAGES_ARRAY_LENGTH];
+
+        layout(location = 0) rayPayloadInNV vec3 payload;
+
+        void main() {
+            sbo.miss_ran = 4;
+
+            payload = vec3(1.0, 0.0, 0.0);
+
+            if (sbo.miss_index > 0) {
+                // OOB here:
+                payload.x = texelFetch(textures[sbo.miss_index], ivec2(0, 0), 0).x;
+            }
+        }
+    )";
+    const std::string miss_source = SetImagesArrayLength(miss_source_template, "6");
+    const std::string miss_source_runtime = SetImagesArrayLength(miss_source_template, "");
+
+    const std::string intr_source_template = R"(#version 460
+        #extension GL_EXT_nonuniform_qualifier : require
+        #extension GL_EXT_samplerless_texture_functions : require
+        #extension GL_NV_ray_tracing : require
+
+        layout(set = 0, binding = 1, std430) buffer StorageBuffer {
+	        uint rgen_index;
+	        uint ahit_index;
+	        uint chit_index;
+	        uint miss_index;
+	        uint intr_index;
+	        uint call_index;
+
+	        uint rgen_ran;
+	        uint ahit_ran;
+	        uint chit_ran;
+	        uint miss_ran;
+	        uint intr_ran;
+	        uint call_ran;
+
+	        float result1;
+	        float result2;
+	        float result3;
+        } sbo;
+        layout(set = 0, binding = 2) uniform texture2D textures[IMAGES_ARRAY_LENGTH];
+
+        hitAttributeNV vec3 hitValue;
+
+        void main() {
+	        sbo.intr_ran = 5;
+
+	        hitValue = vec3(0.0f, 0.5f, 0.0f);
+
+	        reportIntersectionNV(1.0f, 0);
+
+            if (sbo.intr_index > 0) {
+                // OOB here:
+                hitValue.x = texelFetch(textures[sbo.intr_index], ivec2(0, 0), 0).x;
+            }
+        }
+    )";
+    const std::string intr_source = SetImagesArrayLength(intr_source_template, "6");
+    const std::string intr_source_runtime = SetImagesArrayLength(intr_source_template, "");
+
+    const std::string call_source_template = R"(#version 460
+        #extension GL_EXT_nonuniform_qualifier : require
+        #extension GL_EXT_samplerless_texture_functions : require
+        #extension GL_NV_ray_tracing : require
+
+        layout(set = 0, binding = 1, std430) buffer StorageBuffer {
+	        uint rgen_index;
+	        uint ahit_index;
+	        uint chit_index;
+	        uint miss_index;
+	        uint intr_index;
+	        uint call_index;
+
+	        uint rgen_ran;
+	        uint ahit_ran;
+	        uint chit_ran;
+	        uint miss_ran;
+	        uint intr_ran;
+	        uint call_ran;
+
+	        float result1;
+	        float result2;
+	        float result3;
+        } sbo;
+        layout(set = 0, binding = 2) uniform texture2D textures[IMAGES_ARRAY_LENGTH];
+
+        layout(location = 3) callableDataInNV vec3 callableData;
+
+        void main() {
+	        sbo.call_ran = 6;
+
+	        callableData = vec3(0.1234f);
+
+            if (sbo.call_index > 0) {
+                // OOB here:
+                callableData.x = texelFetch(textures[sbo.call_index], ivec2(0, 0), 0).x;
+            }
+        }
+    )";
+    const std::string call_source = SetImagesArrayLength(call_source_template, "6");
+    const std::string call_source_runtime = SetImagesArrayLength(call_source_template, "");
+
+    struct TestCase {
+        const std::string &rgen_shader_source;
+        const std::string &ahit_shader_source;
+        const std::string &chit_shader_source;
+        const std::string &miss_shader_source;
+        const std::string &intr_shader_source;
+        const std::string &call_shader_source;
+        bool variable_length;
+        uint32_t rgen_index;
+        uint32_t ahit_index;
+        uint32_t chit_index;
+        uint32_t miss_index;
+        uint32_t intr_index;
+        uint32_t call_index;
+        const char *expected_error;
+    };
+
+    std::vector<TestCase> tests;
+    tests.push_back({rgen_source, ahit_source, chit_source, miss_source, intr_source, call_source, false, 25, 0, 0, 0, 0, 0,
+                     "Index of 25 used to index descriptor array of length 6."});
+    tests.push_back({rgen_source, ahit_source, chit_source, miss_source, intr_source, call_source, false, 0, 25, 0, 0, 0, 0,
+                     "Index of 25 used to index descriptor array of length 6."});
+    tests.push_back({rgen_source, ahit_source, chit_source, miss_source, intr_source, call_source, false, 0, 0, 25, 0, 0, 0,
+                     "Index of 25 used to index descriptor array of length 6."});
+    tests.push_back({rgen_source, ahit_source, chit_source, miss_source, intr_source, call_source, false, 0, 0, 0, 25, 0, 0,
+                     "Index of 25 used to index descriptor array of length 6."});
+    tests.push_back({rgen_source, ahit_source, chit_source, miss_source, intr_source, call_source, false, 0, 0, 0, 0, 25, 0,
+                     "Index of 25 used to index descriptor array of length 6."});
+    tests.push_back({rgen_source, ahit_source, chit_source, miss_source, intr_source, call_source, false, 0, 0, 0, 0, 0, 25,
+                     "Index of 25 used to index descriptor array of length 6."});
+
+    if (descriptor_indexing) {
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 25, 0, 0, 0, 0, 0, "Index of 25 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 25, 0, 0, 0, 0, "Index of 25 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 25, 0, 0, 0, "Index of 25 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 25, 0, 0, "Index of 25 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 0, 25, 0, "Index of 25 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 0, 0, 25, "Index of 25 used to index descriptor array of length 6."});
+
+        // For this group, 6 is less than max specified (max specified is 8) but more than actual specified (actual specified is 5)
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 6, 0, 0, 0, 0, 0, "Index of 6 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 6, 0, 0, 0, 0, "Index of 6 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 6, 0, 0, 0, "Index of 6 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 6, 0, 0, "Index of 6 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 0, 6, 0, "Index of 6 used to index descriptor array of length 6."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 0, 0, 6, "Index of 6 used to index descriptor array of length 6."});
+
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 5, 0, 0, 0, 0, 0, "Descriptor index 5 is uninitialized."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 5, 0, 0, 0, 0, "Descriptor index 5 is uninitialized."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 5, 0, 0, 0, "Descriptor index 5 is uninitialized."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 5, 0, 0, "Descriptor index 5 is uninitialized."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 0, 5, 0, "Descriptor index 5 is uninitialized."});
+        tests.push_back({rgen_source_runtime, ahit_source_runtime, chit_source_runtime, miss_source_runtime, intr_source_runtime,
+                         call_source_runtime, true, 0, 0, 0, 0, 0, 5, "Descriptor index 5 is uninitialized."});
+    }
+
+    PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV = reinterpret_cast<PFN_vkCreateRayTracingPipelinesNV>(
+        vkGetDeviceProcAddr(m_device->handle(), "vkCreateRayTracingPipelinesNV"));
+    ASSERT_TRUE(vkCreateRayTracingPipelinesNV != nullptr);
+
+    PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV =
+        reinterpret_cast<PFN_vkGetRayTracingShaderGroupHandlesNV>(
+            vkGetDeviceProcAddr(m_device->handle(), "vkGetRayTracingShaderGroupHandlesNV"));
+    ASSERT_TRUE(vkGetRayTracingShaderGroupHandlesNV != nullptr);
+
+    PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV =
+        reinterpret_cast<PFN_vkCmdTraceRaysNV>(vkGetDeviceProcAddr(m_device->handle(), "vkCmdTraceRaysNV"));
+    ASSERT_TRUE(vkCmdTraceRaysNV != nullptr);
+
+    for (const auto &test : tests) {
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, test.expected_error);
+
+        VkShaderObj rgen_shader(m_device, test.rgen_shader_source.c_str(), VK_SHADER_STAGE_RAYGEN_BIT_NV, this, "main");
+        VkShaderObj ahit_shader(m_device, test.ahit_shader_source.c_str(), VK_SHADER_STAGE_ANY_HIT_BIT_NV, this, "main");
+        VkShaderObj chit_shader(m_device, test.chit_shader_source.c_str(), VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV, this, "main");
+        VkShaderObj miss_shader(m_device, test.miss_shader_source.c_str(), VK_SHADER_STAGE_MISS_BIT_NV, this, "main");
+        VkShaderObj intr_shader(m_device, test.intr_shader_source.c_str(), VK_SHADER_STAGE_INTERSECTION_BIT_NV, this, "main");
+        VkShaderObj call_shader(m_device, test.call_shader_source.c_str(), VK_SHADER_STAGE_CALLABLE_BIT_NV, this, "main");
+
+        VkPipelineShaderStageCreateInfo stage_create_infos[6] = {};
+        stage_create_infos[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        stage_create_infos[0].stage = VK_SHADER_STAGE_RAYGEN_BIT_NV;
+        stage_create_infos[0].module = rgen_shader.handle();
+        stage_create_infos[0].pName = "main";
+
+        stage_create_infos[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        stage_create_infos[1].stage = VK_SHADER_STAGE_ANY_HIT_BIT_NV;
+        stage_create_infos[1].module = ahit_shader.handle();
+        stage_create_infos[1].pName = "main";
+
+        stage_create_infos[2].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        stage_create_infos[2].stage = VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV;
+        stage_create_infos[2].module = chit_shader.handle();
+        stage_create_infos[2].pName = "main";
+
+        stage_create_infos[3].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        stage_create_infos[3].stage = VK_SHADER_STAGE_MISS_BIT_NV;
+        stage_create_infos[3].module = miss_shader.handle();
+        stage_create_infos[3].pName = "main";
+
+        stage_create_infos[4].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        stage_create_infos[4].stage = VK_SHADER_STAGE_INTERSECTION_BIT_NV;
+        stage_create_infos[4].module = intr_shader.handle();
+        stage_create_infos[4].pName = "main";
+
+        stage_create_infos[5].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+        stage_create_infos[5].stage = VK_SHADER_STAGE_CALLABLE_BIT_NV;
+        stage_create_infos[5].module = call_shader.handle();
+        stage_create_infos[5].pName = "main";
+
+        VkRayTracingShaderGroupCreateInfoNV group_create_infos[4] = {};
+        group_create_infos[0].sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV;
+        group_create_infos[0].type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV;
+        group_create_infos[0].generalShader = 0;  // rgen
+        group_create_infos[0].closestHitShader = VK_SHADER_UNUSED_NV;
+        group_create_infos[0].anyHitShader = VK_SHADER_UNUSED_NV;
+        group_create_infos[0].intersectionShader = VK_SHADER_UNUSED_NV;
+
+        group_create_infos[1].sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV;
+        group_create_infos[1].type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV;
+        group_create_infos[1].generalShader = 3;  // miss
+        group_create_infos[1].closestHitShader = VK_SHADER_UNUSED_NV;
+        group_create_infos[1].anyHitShader = VK_SHADER_UNUSED_NV;
+        group_create_infos[1].intersectionShader = VK_SHADER_UNUSED_NV;
+
+        group_create_infos[2].sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV;
+        group_create_infos[2].type = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV;
+        group_create_infos[2].generalShader = VK_SHADER_UNUSED_NV;
+        group_create_infos[2].closestHitShader = 2;
+        group_create_infos[2].anyHitShader = 1;
+        group_create_infos[2].intersectionShader = 4;
+
+        group_create_infos[3].sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV;
+        group_create_infos[3].type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV;
+        group_create_infos[3].generalShader = 5;  // call
+        group_create_infos[3].closestHitShader = VK_SHADER_UNUSED_NV;
+        group_create_infos[3].anyHitShader = VK_SHADER_UNUSED_NV;
+        group_create_infos[3].intersectionShader = VK_SHADER_UNUSED_NV;
+
+        VkRayTracingPipelineCreateInfoNV pipeline_ci = {};
+        pipeline_ci.sType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV;
+        pipeline_ci.stageCount = 6;
+        pipeline_ci.pStages = stage_create_infos;
+        pipeline_ci.groupCount = 4;
+        pipeline_ci.pGroups = group_create_infos;
+        pipeline_ci.maxRecursionDepth = 2;
+        pipeline_ci.layout = test.variable_length ? pipeline_layout_variable.handle() : pipeline_layout.handle();
+
+        VkPipeline pipeline = VK_NULL_HANDLE;
+        ASSERT_VK_SUCCESS(vkCreateRayTracingPipelinesNV(m_device->handle(), VK_NULL_HANDLE, 1, &pipeline_ci, nullptr, &pipeline));
+
+        std::vector<uint8_t> shader_binding_table_data;
+        shader_binding_table_data.resize(static_cast<std::size_t>(shader_binding_table_buffer_size), 0);
+        ASSERT_VK_SUCCESS(vkGetRayTracingShaderGroupHandlesNV(m_device->handle(), pipeline, 0, 4,
+                                                              static_cast<std::size_t>(shader_binding_table_buffer_size),
+                                                              shader_binding_table_data.data()));
+
+        uint8_t *mapped_shader_binding_table_data = (uint8_t *)shader_binding_table_buffer.memory().map();
+        std::memcpy(mapped_shader_binding_table_data, shader_binding_table_data.data(), shader_binding_table_data.size());
+        shader_binding_table_buffer.memory().unmap();
+
+        ray_tracing_command_buffer.begin();
+
+        vkCmdBindPipeline(ray_tracing_command_buffer.handle(), VK_PIPELINE_BIND_POINT_RAY_TRACING_NV, pipeline);
+        vkCmdBindDescriptorSets(ray_tracing_command_buffer.handle(), VK_PIPELINE_BIND_POINT_RAY_TRACING_NV,
+                                test.variable_length ? pipeline_layout_variable.handle() : pipeline_layout.handle(), 0, 1,
+                                test.variable_length ? &ds_variable.set_ : &ds.set_, 0, nullptr);
+
+        vkCmdTraceRaysNV(ray_tracing_command_buffer.handle(), shader_binding_table_buffer.handle(),
+                         ray_tracing_properties.shaderGroupHandleSize * 0ull, shader_binding_table_buffer.handle(),
+                         ray_tracing_properties.shaderGroupHandleSize * 1ull, ray_tracing_properties.shaderGroupHandleSize,
+                         shader_binding_table_buffer.handle(), ray_tracing_properties.shaderGroupHandleSize * 2ull,
+                         ray_tracing_properties.shaderGroupHandleSize, shader_binding_table_buffer.handle(),
+                         ray_tracing_properties.shaderGroupHandleSize * 3ull, ray_tracing_properties.shaderGroupHandleSize,
+                         /*width=*/1, /*height=*/1, /*depth=*/1);
+
+        ray_tracing_command_buffer.end();
+
+        // Update the index of the texture that the shaders should read
+        uint32_t *mapped_storage_buffer_data = (uint32_t *)storage_buffer.memory().map();
+        mapped_storage_buffer_data[0] = test.rgen_index;
+        mapped_storage_buffer_data[1] = test.ahit_index;
+        mapped_storage_buffer_data[2] = test.chit_index;
+        mapped_storage_buffer_data[3] = test.miss_index;
+        mapped_storage_buffer_data[4] = test.intr_index;
+        mapped_storage_buffer_data[5] = test.call_index;
+        mapped_storage_buffer_data[6] = 0;
+        mapped_storage_buffer_data[7] = 0;
+        mapped_storage_buffer_data[8] = 0;
+        mapped_storage_buffer_data[9] = 0;
+        mapped_storage_buffer_data[10] = 0;
+        mapped_storage_buffer_data[11] = 0;
+        storage_buffer.memory().unmap();
+
+        vkQueueSubmit(ray_tracing_queue, 1, &submit_info, VK_NULL_HANDLE);
+        vkQueueWaitIdle(ray_tracing_queue);
+        m_errorMonitor->VerifyFound();
+
+        mapped_storage_buffer_data = (uint32_t *)storage_buffer.memory().map();
+        ASSERT_TRUE(mapped_storage_buffer_data[6] == 1);
+        ASSERT_TRUE(mapped_storage_buffer_data[7] == 2);
+        ASSERT_TRUE(mapped_storage_buffer_data[8] == 3);
+        ASSERT_TRUE(mapped_storage_buffer_data[9] == 4);
+        ASSERT_TRUE(mapped_storage_buffer_data[10] == 5);
+        ASSERT_TRUE(mapped_storage_buffer_data[11] == 6);
+        storage_buffer.memory().unmap();
+
+        vkDestroyPipeline(m_device->handle(), pipeline, nullptr);
+    }
+}
+
 TEST_F(VkLayerTest, InvalidDescriptorPoolConsistency) {
     VkResult err;
 
@@ -1102,6 +2088,96 @@ TEST_F(VkLayerTest, RenderPassCreateInvalidInputAttachmentReferences) {
     TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, false, "VUID-VkRenderPassCreateInfo-pNext-01927", nullptr);
 }
 
+TEST_F(VkLayerTest, RenderPassCreateInvalidFragmentDensityMapReferences) {
+    TEST_DESCRIPTION("Create a subpass with the wrong attachment information for a fragment density map ");
+
+    // Check for VK_KHR_get_physical_device_properties2
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Extension %s is not supported.\n", kSkipPrefix, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME);
+    } else {
+        printf("%s Extension %s is not supported.\n", kSkipPrefix, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+
+    VkAttachmentDescription attach = {0,
+                                      VK_FORMAT_R8G8_UNORM,
+                                      VK_SAMPLE_COUNT_1_BIT,
+                                      VK_ATTACHMENT_LOAD_OP_LOAD,
+                                      VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                                      VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                      VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                                      VK_IMAGE_LAYOUT_UNDEFINED,
+                                      VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT};
+    // Set 1 instead of 0
+    VkAttachmentReference ref = {1, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT};
+    VkSubpassDescription subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 1, &ref, 0, nullptr, nullptr, nullptr, 0, nullptr};
+    VkRenderPassFragmentDensityMapCreateInfoEXT rpfdmi = {VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
+                                                          nullptr, ref};
+
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, &rpfdmi, 0, 1, &attach, 1, &subpass, 0, nullptr};
+
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, false,
+                         "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02547", nullptr);
+
+    // Set wrong VkImageLayout
+    ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
+    subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 1, &ref, 0, nullptr, nullptr, nullptr, 0, nullptr};
+    rpfdmi = {VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, nullptr, ref};
+    rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, &rpfdmi, 0, 1, &attach, 1, &subpass, 0, nullptr};
+
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, false,
+                         "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02549", nullptr);
+
+    // Set wrong load operation
+    attach = {0,
+              VK_FORMAT_R8G8_UNORM,
+              VK_SAMPLE_COUNT_1_BIT,
+              VK_ATTACHMENT_LOAD_OP_CLEAR,
+              VK_ATTACHMENT_STORE_OP_DONT_CARE,
+              VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+              VK_ATTACHMENT_STORE_OP_DONT_CARE,
+              VK_IMAGE_LAYOUT_UNDEFINED,
+              VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT};
+
+    ref = {0, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT};
+    subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 1, &ref, 0, nullptr, nullptr, nullptr, 0, nullptr};
+    rpfdmi = {VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, nullptr, ref};
+    rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, &rpfdmi, 0, 1, &attach, 1, &subpass, 0, nullptr};
+
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, false,
+                         "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02550", nullptr);
+
+    // Set wrong store operation
+    attach = {0,
+              VK_FORMAT_R8G8_UNORM,
+              VK_SAMPLE_COUNT_1_BIT,
+              VK_ATTACHMENT_LOAD_OP_LOAD,
+              VK_ATTACHMENT_STORE_OP_STORE,
+              VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+              VK_ATTACHMENT_STORE_OP_DONT_CARE,
+              VK_IMAGE_LAYOUT_UNDEFINED,
+              VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT};
+
+    ref = {0, VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT};
+    subpass = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 1, &ref, 0, nullptr, nullptr, nullptr, 0, nullptr};
+    rpfdmi = {VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT, nullptr, ref};
+    rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, &rpfdmi, 0, 1, &attach, 1, &subpass, 0, nullptr};
+
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, false,
+                         "VUID-VkRenderPassFragmentDensityMapCreateInfoEXT-fragmentDensityMapAttachment-02551", nullptr);
+}
+
 TEST_F(VkLayerTest, RenderPassCreateSubpassNonGraphicsPipeline) {
     TEST_DESCRIPTION("Create a subpass with the compute pipeline bind point");
     // Check for VK_KHR_get_physical_device_properties2
@@ -1217,10 +2293,10 @@ TEST_F(VkLayerTest, RenderPassCreateInvalidSubpassDependencies) {
 
     ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
 
-    bool rp2Supported = CheckCreateRenderPass2Support(this, m_device_extension_names);
-    bool multiviewSupported = rp2Supported;
+    bool rp2_supported = CheckCreateRenderPass2Support(this, m_device_extension_names);
+    bool multiviewSupported = rp2_supported;
 
-    if (!rp2Supported && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+    if (!rp2_supported && DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
         m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
         multiviewSupported = true;
     }
@@ -1241,92 +2317,96 @@ TEST_F(VkLayerTest, RenderPassCreateInvalidSubpassDependencies) {
 
     VkSubpassDependency dependency;
     VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, 0, nullptr, 2, subpasses, 1, &dependency};
-    // dependency = { 0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0 };
 
-    // Source subpass is not EXTERNAL, so source stage mask must not include HOST
-    dependency = {0, 1, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
+    // Non graphics stages in subpass dependency
+    dependency = {0, 1, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_TRANSFER_BIT,
+                  VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00837", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054");
+
+    dependency = {0, 1, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, 0};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00837", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054");
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcSubpass-00858",
-                         "VUID-VkSubpassDependency2KHR-srcSubpass-03078");
+    dependency = {0, 1, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, 0, 0};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00837", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054");
+
+    dependency = {0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                  VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00838", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055");
 
-    // Destination subpass is not EXTERNAL, so destination stage mask must not include HOST
     dependency = {0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0, 0};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00838", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055");
+
+    dependency = {0, VK_SUBPASS_EXTERNAL, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, 0};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00837", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054");
+
+    dependency = {VK_SUBPASS_EXTERNAL, 0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, 0};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00838", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055");
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-dstSubpass-00859",
-                         "VUID-VkSubpassDependency2KHR-dstSubpass-03079");
+    dependency = {0, 0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
+                         "VUID-VkRenderPassCreateInfo-pDependencies-00837", "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054");
 
     // Geometry shaders not enabled source
     dependency = {0, 1, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcStageMask-00860",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-srcStageMask-00860",
                          "VUID-VkSubpassDependency2KHR-srcStageMask-03080");
 
     // Geometry shaders not enabled destination
     dependency = {0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT, 0, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-dstStageMask-00861",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-dstStageMask-00861",
                          "VUID-VkSubpassDependency2KHR-dstStageMask-03081");
 
     // Tessellation not enabled source
     dependency = {0, 1, VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcStageMask-00862",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-srcStageMask-00862",
                          "VUID-VkSubpassDependency2KHR-srcStageMask-03082");
 
     // Tessellation not enabled destination
     dependency = {0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT, 0, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-dstStageMask-00863",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-dstStageMask-00863",
                          "VUID-VkSubpassDependency2KHR-dstStageMask-03083");
 
     // Potential cyclical dependency
     dependency = {1, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcSubpass-00864",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-srcSubpass-00864",
                          "VUID-VkSubpassDependency2KHR-srcSubpass-03084");
 
     // EXTERNAL to EXTERNAL dependency
     dependency = {
         VK_SUBPASS_EXTERNAL, VK_SUBPASS_EXTERNAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcSubpass-00865",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-srcSubpass-00865",
                          "VUID-VkSubpassDependency2KHR-srcSubpass-03085");
 
-    // Source compute stage not part of subpass 0's GRAPHICS pipeline
-    dependency = {0, VK_SUBPASS_EXTERNAL, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, 0};
-
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkRenderPassCreateInfo-pDependencies-00837",
-                         "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03054");
-
-    // Destination compute stage not part of subpass 0's GRAPHICS pipeline
-    dependency = {VK_SUBPASS_EXTERNAL, 0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, 0};
-
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkRenderPassCreateInfo-pDependencies-00838",
-                         "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03055");
-
-    // Non graphics stage in self dependency
-    dependency = {0, 0, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, 0};
-
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcSubpass-01989",
-                         "VUID-VkSubpassDependency2KHR-srcSubpass-02244");
-
     // Logically later source stages in self dependency
     dependency = {0, 0, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT, VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, 0, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcSubpass-00867",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-srcSubpass-00867",
                          "VUID-VkSubpassDependency2KHR-srcSubpass-03087");
 
     // Source access mask mismatch with source stage mask
     dependency = {0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_ACCESS_UNIFORM_READ_BIT, 0, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcAccessMask-00868",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-srcAccessMask-00868",
                          "VUID-VkSubpassDependency2KHR-srcAccessMask-03088");
 
     // Destination access mask mismatch with destination stage mask
     dependency = {
         0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, 0};
 
-    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-dstAccessMask-00869",
+    TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-dstAccessMask-00869",
                          "VUID-VkSubpassDependency2KHR-dstAccessMask-03089");
 
     if (multiviewSupported) {
@@ -1334,7 +2414,7 @@ TEST_F(VkLayerTest, RenderPassCreateInvalidSubpassDependencies) {
         dependency = {0, 1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                       0, 0, VK_DEPENDENCY_VIEW_LOCAL_BIT};
 
-        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, nullptr,
+        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, nullptr,
                              "VUID-VkRenderPassCreateInfo2KHR-viewMask-03059");
 
         // Enable multiview
@@ -1366,13 +2446,13 @@ TEST_F(VkLayerTest, RenderPassCreateInvalidSubpassDependencies) {
         rpmvci.dependencyCount = 0;
 
         // View offset with no view local bit
-        if (rp2Supported) {
+        if (rp2_supported) {
             dependency = {0, VK_SUBPASS_EXTERNAL, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
             rpmvci.pViewOffsets = pViewOffsets;
             pViewOffsets[0] = 1;
             rpmvci.dependencyCount = 1;
 
-            TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, nullptr,
+            TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, nullptr,
                                  "VUID-VkSubpassDependency2KHR-dependencyFlags-03092");
 
             rpmvci.dependencyCount = 0;
@@ -1382,7 +2462,7 @@ TEST_F(VkLayerTest, RenderPassCreateInvalidSubpassDependencies) {
         dependency = {VK_SUBPASS_EXTERNAL,         1, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0,
                       VK_DEPENDENCY_VIEW_LOCAL_BIT};
 
-        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported,
+        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
                              "VUID-VkSubpassDependency-dependencyFlags-02520",
                              "VUID-VkSubpassDependency2KHR-dependencyFlags-03090");
 
@@ -1390,14 +2470,14 @@ TEST_F(VkLayerTest, RenderPassCreateInvalidSubpassDependencies) {
         dependency = {0, VK_SUBPASS_EXTERNAL,         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0,
                       0, VK_DEPENDENCY_VIEW_LOCAL_BIT};
 
-        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported,
+        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported,
                              "VUID-VkSubpassDependency-dependencyFlags-02521",
                              "VUID-VkSubpassDependency2KHR-dependencyFlags-03091");
 
         // Multiple views but no view local bit in self-dependency
         dependency = {0, 0, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, 0};
 
-        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2Supported, "VUID-VkSubpassDependency-srcSubpass-00872",
+        TestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported, "VUID-VkSubpassDependency-srcSubpass-00872",
                              "VUID-VkRenderPassCreateInfo2KHR-pDependencies-03060");
     }
 }
@@ -2115,9 +3195,26 @@ TEST_F(VkLayerTest, FramebufferCreateErrors) {
         " 6. Framebuffer attachment where dimensions don't match\n"
         " 7. Framebuffer attachment where dimensions don't match\n"
         " 8. Framebuffer attachment w/o identity swizzle\n"
-        " 9. framebuffer dimensions exceed physical device limits\n");
+        " 9. framebuffer dimensions exceed physical device limits\n"
+        "10. null pAttachments\n");
 
-    ASSERT_NO_FATAL_FAILURE(Init());
+    // Check for VK_KHR_get_physical_device_properties2
+    bool push_physical_device_properties_2_support =
+        InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    if (push_physical_device_properties_2_support) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    bool push_fragment_density_support = false;
+
+    if (push_physical_device_properties_2_support) {
+        push_fragment_density_support = DeviceExtensionSupported(gpu(), nullptr, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME);
+        if (push_fragment_density_support) m_device_extension_names.push_back(VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME);
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, 0));
     ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
 
     m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-attachmentCount-00876");
@@ -2274,6 +3371,120 @@ TEST_F(VkLayerTest, FramebufferCreateErrors) {
     }
 
     {
+        if (!push_fragment_density_support) {
+            printf("%s VK_EXT_fragment_density_map Extension not supported, skipping tests\n", kSkipPrefix);
+        } else {
+            uint32_t attachment_width = 512;
+            uint32_t attachment_height = 512;
+            VkFormat attachment_format = VK_FORMAT_R8G8_UNORM;
+            uint32_t frame_width = 512;
+            uint32_t frame_height = 512;
+
+            // Create a renderPass with a single color attachment for fragment density map
+            VkAttachmentReference attach_fragment_density_map = {};
+            attach_fragment_density_map.layout = VK_IMAGE_LAYOUT_GENERAL;
+            VkSubpassDescription subpass_fragment_density_map = {};
+            subpass_fragment_density_map.pColorAttachments = &attach_fragment_density_map;
+            VkRenderPassCreateInfo rpci_fragment_density_map = {};
+            rpci_fragment_density_map.subpassCount = 1;
+            rpci_fragment_density_map.pSubpasses = &subpass_fragment_density_map;
+            rpci_fragment_density_map.attachmentCount = 1;
+            VkAttachmentDescription attach_desc_fragment_density_map = {};
+            attach_desc_fragment_density_map.format = attachment_format;
+            attach_desc_fragment_density_map.samples = VK_SAMPLE_COUNT_1_BIT;
+            attach_desc_fragment_density_map.finalLayout = VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT;
+            rpci_fragment_density_map.pAttachments = &attach_desc_fragment_density_map;
+            rpci_fragment_density_map.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+            VkRenderPass rp_fragment_density_map;
+
+            err = vkCreateRenderPass(m_device->device(), &rpci_fragment_density_map, NULL, &rp_fragment_density_map);
+            ASSERT_VK_SUCCESS(err);
+
+            // Create view attachment
+            VkImageView view_fragment_density_map;
+            VkImageViewCreateInfo ivci = {};
+            ivci.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+            ivci.viewType = VK_IMAGE_VIEW_TYPE_2D;
+            ivci.format = attachment_format;
+            ivci.flags = 0;
+            ivci.subresourceRange.layerCount = 1;
+            ivci.subresourceRange.baseMipLevel = 0;
+            ivci.subresourceRange.levelCount = 1;
+            ivci.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+
+            VkFramebufferAttachmentImageInfoKHR fb_fdm = {};
+            fb_fdm.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+            fb_fdm.usage = VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT;
+            fb_fdm.width = frame_width;
+            fb_fdm.height = frame_height;
+            fb_fdm.layerCount = 1;
+            fb_fdm.viewFormatCount = 1;
+            fb_fdm.pViewFormats = &attachment_format;
+            VkFramebufferAttachmentsCreateInfoKHR fb_aci_fdm = {};
+            fb_aci_fdm.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR;
+            fb_aci_fdm.attachmentImageInfoCount = 1;
+            fb_aci_fdm.pAttachmentImageInfos = &fb_fdm;
+
+            VkFramebufferCreateInfo fbci = {};
+            fbci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+            fbci.pNext = &fb_aci_fdm;
+            fbci.flags = 0;
+            fbci.width = frame_width;
+            fbci.height = frame_height;
+            fbci.layers = 1;
+            fbci.renderPass = rp_fragment_density_map;
+            fbci.attachmentCount = 1;
+            fbci.pAttachments = &view_fragment_density_map;
+
+            // Set small width
+            VkImageObj image2(m_device);
+            image2.Init(16, attachment_height, 1, attachment_format, VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT,
+                        VK_IMAGE_TILING_LINEAR, 0);
+            ASSERT_TRUE(image2.initialized());
+
+            ivci.image = image2.handle();
+            err = vkCreateImageView(m_device->device(), &ivci, NULL, &view_fragment_density_map);
+            ASSERT_VK_SUCCESS(err);
+
+            fbci.pAttachments = &view_fragment_density_map;
+
+            m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-pAttachments-02555");
+            err = vkCreateFramebuffer(device(), &fbci, NULL, &fb);
+
+            m_errorMonitor->VerifyFound();
+            if (err == VK_SUCCESS) {
+                vkDestroyFramebuffer(m_device->device(), fb, NULL);
+            }
+
+            vkDestroyImageView(m_device->device(), view_fragment_density_map, NULL);
+
+            // Set small height
+            VkImageObj image3(m_device);
+            image3.Init(attachment_width, 16, 1, attachment_format, VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT,
+                        VK_IMAGE_TILING_LINEAR, 0);
+            ASSERT_TRUE(image3.initialized());
+
+            ivci.image = image3.handle();
+            err = vkCreateImageView(m_device->device(), &ivci, NULL, &view_fragment_density_map);
+            ASSERT_VK_SUCCESS(err);
+
+            fbci.pAttachments = &view_fragment_density_map;
+
+            m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-pAttachments-02556");
+            err = vkCreateFramebuffer(device(), &fbci, NULL, &fb);
+
+            m_errorMonitor->VerifyFound();
+            if (err == VK_SUCCESS) {
+                vkDestroyFramebuffer(m_device->device(), fb, NULL);
+            }
+
+            vkDestroyImageView(m_device->device(), view_fragment_density_map, NULL);
+
+            vkDestroyRenderPass(m_device->device(), rp_fragment_density_map, NULL);
+        }
+    }
+
+    {
         // Create an image with one mip level.
         VkImageObj image(m_device);
         image.Init(128, 128, 1, VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
@@ -2375,6 +3586,16 @@ TEST_F(VkLayerTest, FramebufferCreateErrors) {
         vkDestroyFramebuffer(m_device->device(), fb, NULL);
     }
 
+    // Try to create with pAttachments = NULL
+    fb_info.layers = 1;
+    fb_info.pAttachments = NULL;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID_Undefined");
+    err = vkCreateFramebuffer(device(), &fb_info, NULL, &fb);
+    m_errorMonitor->VerifyFound();
+    if (err == VK_SUCCESS) {
+        vkDestroyFramebuffer(m_device->device(), fb, NULL);
+    }
+
     vkDestroyRenderPass(m_device->device(), rp, NULL);
 }
 
@@ -6018,4 +7239,4 @@ TEST_F(VkLayerTest, InlineUniformBlockEXT) {
 
     vkDestroyDescriptorPool(m_device->handle(), ds_pool, nullptr);
     vkDestroyDescriptorSetLayout(m_device->device(), ds_layout, nullptr);
-}
+}
\ No newline at end of file
diff --git a/tests/vklayertests_imageless_framebuffer.cpp b/tests/vklayertests_imageless_framebuffer.cpp
new file mode 100644
index 000000000..1139f62d9
--- /dev/null
+++ b/tests/vklayertests_imageless_framebuffer.cpp
@@ -0,0 +1,1084 @@
+/*
+ * Copyright (c) 2015-2019 The Khronos Group Inc.
+ * Copyright (c) 2015-2019 Valve Corporation
+ * Copyright (c) 2015-2019 LunarG, Inc.
+ * Copyright (c) 2015-2019 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
+ *
+ * Author: Chia-I Wu <olvaffe@gmail.com>
+ * Author: Chris Forbes <chrisf@ijw.co.nz>
+ * Author: Courtney Goeltzenleuchter <courtney@LunarG.com>
+ * Author: Mark Lobodzinski <mark@lunarg.com>
+ * Author: Mike Stroyan <mike@LunarG.com>
+ * Author: Tobin Ehlis <tobine@google.com>
+ * Author: Tony Barbour <tony@LunarG.com>
+ * Author: Cody Northrop <cnorthrop@google.com>
+ * Author: Dave Houlton <daveh@lunarg.com>
+ * Author: Jeremy Kniager <jeremyk@lunarg.com>
+ * Author: Shannon McPherson <shannon@lunarg.com>
+ * Author: John Zulauf <jzulauf@lunarg.com>
+ * Author: Tobias Hector <tobias.hector@amd.com>
+ */
+
+#include "cast_utils.h"
+#include "layer_validation_tests.h"
+
+TEST_F(VkLayerTest, ImagelessFramebufferRenderPassBeginImageViewMismatchTests) {
+    TEST_DESCRIPTION(
+        "Begin a renderPass where the image views specified do not match the parameters used to create the framebuffer and render "
+        "pass.");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+    bool rp2Supported = CheckCreateRenderPass2Support(this, m_device_extension_names);
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_MAINTENANCE2_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+    } else {
+        printf("%s test requires VK_KHR_imageless_framebuffer, not available.  Skipping.\n", kSkipPrefix);
+        return;
+    }
+
+    VkPhysicalDeviceImagelessFramebufferFeaturesKHR physicalDeviceImagelessFramebufferFeatures = {};
+    physicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR;
+    physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer = VK_TRUE;
+    VkPhysicalDeviceFeatures2 physicalDeviceFeatures2 = {};
+    physicalDeviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+    physicalDeviceFeatures2.pNext = &physicalDeviceImagelessFramebufferFeatures;
+
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &physicalDeviceFeatures2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+
+    uint32_t attachmentWidth = 512;
+    uint32_t attachmentHeight = 512;
+    VkFormat attachmentFormats[2] = {VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM};
+    VkFormat framebufferAttachmentFormats[3] = {VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM};
+
+    // Create a renderPass with a single attachment
+    VkAttachmentDescription attachmentDescription = {};
+    attachmentDescription.format = attachmentFormats[0];
+    attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    VkAttachmentReference attachmentReference = {};
+    attachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    VkSubpassDescription subpassDescription = {};
+    subpassDescription.colorAttachmentCount = 1;
+    subpassDescription.pColorAttachments = &attachmentReference;
+    VkRenderPassCreateInfo renderPassCreateInfo = {};
+    renderPassCreateInfo.subpassCount = 1;
+    renderPassCreateInfo.pSubpasses = &subpassDescription;
+    renderPassCreateInfo.attachmentCount = 1;
+    renderPassCreateInfo.pAttachments = &attachmentDescription;
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    VkRenderPass renderPass;
+    vkCreateRenderPass(m_device->device(), &renderPassCreateInfo, NULL, &renderPass);
+
+    VkFramebufferAttachmentImageInfoKHR framebufferAttachmentImageInfo = {};
+    framebufferAttachmentImageInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfo.width = attachmentWidth;
+    framebufferAttachmentImageInfo.height = attachmentHeight;
+    framebufferAttachmentImageInfo.layerCount = 1;
+    framebufferAttachmentImageInfo.viewFormatCount = 2;
+    framebufferAttachmentImageInfo.pViewFormats = framebufferAttachmentFormats;
+    VkFramebufferAttachmentsCreateInfoKHR framebufferAttachmentsCreateInfo = {};
+    framebufferAttachmentsCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR;
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 1;
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = &framebufferAttachmentImageInfo;
+    VkFramebufferCreateInfo framebufferCreateInfo = {};
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = &framebufferAttachmentsCreateInfo;
+    framebufferCreateInfo.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR;
+    framebufferCreateInfo.width = attachmentWidth;
+    framebufferCreateInfo.height = attachmentHeight;
+    framebufferCreateInfo.layers = 1;
+    framebufferCreateInfo.attachmentCount = 1;
+    framebufferCreateInfo.pAttachments = nullptr;
+    framebufferCreateInfo.renderPass = renderPass;
+    VkFramebuffer framebuffer;
+
+    VkImageFormatListCreateInfoKHR imageFormatListCreateInfo = {};
+    imageFormatListCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR;
+    imageFormatListCreateInfo.viewFormatCount = 2;
+    imageFormatListCreateInfo.pViewFormats = attachmentFormats;
+    VkImageCreateInfo imageCreateInfo = {};
+    imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+    imageCreateInfo.pNext = &imageFormatListCreateInfo;
+    imageCreateInfo.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
+    imageCreateInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    imageCreateInfo.extent.width = attachmentWidth;
+    imageCreateInfo.extent.height = attachmentHeight;
+    imageCreateInfo.extent.depth = 1;
+    imageCreateInfo.arrayLayers = 1;
+    imageCreateInfo.mipLevels = 10;
+    imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
+    imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+    imageCreateInfo.format = attachmentFormats[0];
+
+    VkImageObj imageObject(m_device);
+    imageObject.init(&imageCreateInfo);
+    VkImage image = imageObject.image();
+
+    VkImageViewCreateInfo imageViewCreateInfo = {};
+    imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
+    imageViewCreateInfo.image = image;
+    imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
+    imageViewCreateInfo.format = attachmentFormats[0];
+    imageViewCreateInfo.subresourceRange.layerCount = 1;
+    imageViewCreateInfo.subresourceRange.levelCount = 1;
+    imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    VkImageView imageView;
+    vkCreateImageView(m_device->device(), &imageViewCreateInfo, NULL, &imageView);
+
+    VkRenderPassAttachmentBeginInfoKHR renderPassAttachmentBeginInfo = {};
+    renderPassAttachmentBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR;
+    renderPassAttachmentBeginInfo.pNext = nullptr;
+    renderPassAttachmentBeginInfo.attachmentCount = 1;
+    renderPassAttachmentBeginInfo.pAttachments = &imageView;
+    VkRenderPassBeginInfo renderPassBeginInfo = {};
+    renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
+    renderPassBeginInfo.pNext = &renderPassAttachmentBeginInfo;
+    renderPassBeginInfo.renderPass = renderPass;
+    renderPassBeginInfo.renderArea.extent.width = attachmentWidth;
+    renderPassBeginInfo.renderArea.extent.height = attachmentHeight;
+
+    // Imageless framebuffer creation bit not present
+    framebufferCreateInfo.pAttachments = &imageView;
+    framebufferCreateInfo.flags = 0;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03207", "VUID-VkRenderPassBeginInfo-framebuffer-03207");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferCreateInfo.pAttachments = nullptr;
+    framebufferCreateInfo.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR;
+
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassAttachmentBeginInfo.attachmentCount = 2;
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03208", "VUID-VkRenderPassBeginInfo-framebuffer-03208");
+    renderPassAttachmentBeginInfo.attachmentCount = 1;
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+
+    // Mismatched number of attachments
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassAttachmentBeginInfo.attachmentCount = 2;
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03208", "VUID-VkRenderPassBeginInfo-framebuffer-03208");
+    renderPassAttachmentBeginInfo.attachmentCount = 1;
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+
+    // Mismatched flags
+    framebufferAttachmentImageInfo.flags = 0;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03209", "VUID-VkRenderPassBeginInfo-framebuffer-03209");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferAttachmentImageInfo.flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
+
+    // Mismatched usage
+    framebufferAttachmentImageInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03210", "VUID-VkRenderPassBeginInfo-framebuffer-03210");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferAttachmentImageInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+    // Mismatched width
+    framebufferAttachmentImageInfo.width += 1;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03211", "VUID-VkRenderPassBeginInfo-framebuffer-03211");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferAttachmentImageInfo.width -= 1;
+
+    // Mismatched height
+    framebufferAttachmentImageInfo.height += 1;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03212", "VUID-VkRenderPassBeginInfo-framebuffer-03212");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferAttachmentImageInfo.height -= 1;
+
+    // Mismatched layer count
+    framebufferAttachmentImageInfo.layerCount += 1;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03213", "VUID-VkRenderPassBeginInfo-framebuffer-03213");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferAttachmentImageInfo.layerCount -= 1;
+
+    // Mismatched view format count
+    framebufferAttachmentImageInfo.viewFormatCount = 3;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03214", "VUID-VkRenderPassBeginInfo-framebuffer-03214");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferAttachmentImageInfo.viewFormatCount = 2;
+
+    // Mismatched format lists
+    framebufferAttachmentFormats[1] = VK_FORMAT_B8G8R8A8_SRGB;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03215", "VUID-VkRenderPassBeginInfo-framebuffer-03215");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    framebufferAttachmentFormats[1] = VK_FORMAT_B8G8R8A8_UNORM;
+
+    // Mismatched formats
+    VkImageView imageView2;
+    imageViewCreateInfo.format = attachmentFormats[1];
+    vkCreateImageView(m_device->device(), &imageViewCreateInfo, nullptr, &imageView2);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView2;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03216", "VUID-VkRenderPassBeginInfo-framebuffer-03216");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    vkDestroyImageView(m_device->device(), imageView2, nullptr);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView;
+    imageViewCreateInfo.format = attachmentFormats[0];
+
+    // Mismatched sample counts
+    imageCreateInfo.samples = VK_SAMPLE_COUNT_4_BIT;
+    imageCreateInfo.mipLevels = 1;
+    VkImageObj imageObject2(m_device);
+    imageObject2.init(&imageCreateInfo);
+    imageViewCreateInfo.image = imageObject2.image();
+    vkCreateImageView(m_device->device(), &imageViewCreateInfo, nullptr, &imageView2);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView2;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassBeginInfo-framebuffer-03217", "VUID-VkRenderPassBeginInfo-framebuffer-03217");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    vkDestroyImageView(m_device->device(), imageView2, nullptr);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView;
+    imageViewCreateInfo.image = imageObject.image();
+    imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
+    imageCreateInfo.mipLevels = 10;
+
+    // Mismatched level counts
+    imageViewCreateInfo.subresourceRange.levelCount = 2;
+    vkCreateImageView(m_device->device(), &imageViewCreateInfo, nullptr, &imageView2);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView2;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassAttachmentBeginInfoKHR-pAttachments-03218",
+                        "VUID-VkRenderPassAttachmentBeginInfoKHR-pAttachments-03218");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    vkDestroyImageView(m_device->device(), imageView2, nullptr);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView;
+    imageViewCreateInfo.subresourceRange.levelCount = 1;
+
+    // Non-identity component swizzle
+    imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_A;
+    vkCreateImageView(m_device->device(), &imageViewCreateInfo, nullptr, &imageView2);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView2;
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    renderPassBeginInfo.framebuffer = framebuffer;
+    TestRenderPassBegin(m_errorMonitor, m_device->device(), m_commandBuffer->handle(), &renderPassBeginInfo, rp2Supported,
+                        "VUID-VkRenderPassAttachmentBeginInfoKHR-pAttachments-03219",
+                        "VUID-VkRenderPassAttachmentBeginInfoKHR-pAttachments-03219");
+    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    vkDestroyImageView(m_device->device(), imageView2, nullptr);
+    renderPassAttachmentBeginInfo.pAttachments = &imageView;
+    imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
+
+    vkDestroyRenderPass(m_device->device(), renderPass, nullptr);
+    //    vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    vkDestroyImageView(m_device->device(), imageView, nullptr);
+}
+
+TEST_F(VkLayerTest, ImagelessFramebufferFeatureEnableTest) {
+    TEST_DESCRIPTION("Use imageless framebuffer functionality without enabling the feature");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_MAINTENANCE2_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, nullptr, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    uint32_t attachmentWidth = 512;
+    uint32_t attachmentHeight = 512;
+    VkFormat attachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+
+    // Create a renderPass with a single attachment
+    VkAttachmentDescription attachmentDescription = {};
+    attachmentDescription.format = attachmentFormat;
+    attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    VkAttachmentReference attachmentReference = {};
+    attachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    VkSubpassDescription subpassDescription = {};
+    subpassDescription.colorAttachmentCount = 1;
+    subpassDescription.pColorAttachments = &attachmentReference;
+    VkRenderPassCreateInfo renderPassCreateInfo = {};
+    renderPassCreateInfo.subpassCount = 1;
+    renderPassCreateInfo.pSubpasses = &subpassDescription;
+    renderPassCreateInfo.attachmentCount = 1;
+    renderPassCreateInfo.pAttachments = &attachmentDescription;
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    VkRenderPass renderPass;
+    vkCreateRenderPass(m_device->device(), &renderPassCreateInfo, NULL, &renderPass);
+
+    VkFramebufferAttachmentImageInfoKHR framebufferAttachmentImageInfo = {};
+    framebufferAttachmentImageInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfo.width = attachmentWidth;
+    framebufferAttachmentImageInfo.height = attachmentHeight;
+    framebufferAttachmentImageInfo.layerCount = 1;
+    framebufferAttachmentImageInfo.viewFormatCount = 1;
+    framebufferAttachmentImageInfo.pViewFormats = &attachmentFormat;
+    VkFramebufferAttachmentsCreateInfoKHR framebufferAttachmentsCreateInfo = {};
+    framebufferAttachmentsCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR;
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 1;
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = &framebufferAttachmentImageInfo;
+    VkFramebufferCreateInfo framebufferCreateInfo = {};
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = &framebufferAttachmentsCreateInfo;
+    framebufferCreateInfo.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR;
+    framebufferCreateInfo.width = attachmentWidth;
+    framebufferCreateInfo.height = attachmentHeight;
+    framebufferCreateInfo.layers = 1;
+    framebufferCreateInfo.renderPass = renderPass;
+    framebufferCreateInfo.attachmentCount = 1;
+    VkFramebuffer framebuffer = VK_NULL_HANDLE;
+
+    // Imageless framebuffer creation bit not present
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03189");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    vkDestroyRenderPass(m_device->device(), renderPass, nullptr);
+}
+
+TEST_F(VkLayerTest, ImagelessFramebufferCreationTests) {
+    TEST_DESCRIPTION("Create an imageless framebuffer in various invalid ways");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+    bool rp2Supported = CheckCreateRenderPass2Support(this, m_device_extension_names);
+
+    bool multiviewSupported = rp2Supported;
+    if (!rp2Supported) {
+        if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+            m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
+            multiviewSupported = true;
+        }
+    }
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_MAINTENANCE2_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+        return;
+    }
+
+    VkPhysicalDeviceImagelessFramebufferFeaturesKHR physicalDeviceImagelessFramebufferFeatures = {};
+    physicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR;
+    physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer = VK_TRUE;
+    VkPhysicalDeviceFeatures2 physicalDeviceFeatures2 = {};
+    physicalDeviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+    physicalDeviceFeatures2.pNext = &physicalDeviceImagelessFramebufferFeatures;
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &physicalDeviceFeatures2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    uint32_t attachmentWidth = 512;
+    uint32_t attachmentHeight = 512;
+    VkFormat attachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+
+    // Create a renderPass with a single attachment
+    VkAttachmentDescription attachmentDescription = {};
+    attachmentDescription.format = attachmentFormat;
+    attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    VkAttachmentReference attachmentReference = {};
+    attachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    VkSubpassDescription subpassDescription = {};
+    subpassDescription.colorAttachmentCount = 1;
+    subpassDescription.pColorAttachments = &attachmentReference;
+    VkRenderPassCreateInfo renderPassCreateInfo = {};
+    renderPassCreateInfo.subpassCount = 1;
+    renderPassCreateInfo.pSubpasses = &subpassDescription;
+    renderPassCreateInfo.attachmentCount = 1;
+    renderPassCreateInfo.pAttachments = &attachmentDescription;
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    VkRenderPass renderPass;
+    vkCreateRenderPass(m_device->device(), &renderPassCreateInfo, NULL, &renderPass);
+
+    VkFramebufferAttachmentImageInfoKHR framebufferAttachmentImageInfo = {};
+    framebufferAttachmentImageInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfo.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfo.width = attachmentWidth;
+    framebufferAttachmentImageInfo.height = attachmentHeight;
+    framebufferAttachmentImageInfo.layerCount = 1;
+    framebufferAttachmentImageInfo.viewFormatCount = 1;
+    framebufferAttachmentImageInfo.pViewFormats = &attachmentFormat;
+    VkFramebufferAttachmentsCreateInfoKHR framebufferAttachmentsCreateInfo = {};
+    framebufferAttachmentsCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR;
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 1;
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = &framebufferAttachmentImageInfo;
+    VkFramebufferCreateInfo framebufferCreateInfo = {};
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = &framebufferAttachmentsCreateInfo;
+    framebufferCreateInfo.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR;
+    framebufferCreateInfo.width = attachmentWidth;
+    framebufferCreateInfo.height = attachmentHeight;
+    framebufferCreateInfo.layers = 1;
+    framebufferCreateInfo.renderPass = renderPass;
+    framebufferCreateInfo.attachmentCount = 1;
+    VkFramebuffer framebuffer = VK_NULL_HANDLE;
+
+    // Attachments info not present
+    framebufferCreateInfo.pNext = nullptr;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03190");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferCreateInfo.pNext = &framebufferAttachmentsCreateInfo;
+
+    // Mismatched attachment counts
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 2;
+    VkFramebufferAttachmentImageInfoKHR framebufferAttachmentImageInfos[2] = {framebufferAttachmentImageInfo,
+                                                                              framebufferAttachmentImageInfo};
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = framebufferAttachmentImageInfos;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03191");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = &framebufferAttachmentImageInfo;
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 1;
+
+    // Mismatched format list
+    attachmentFormat = VK_FORMAT_B8G8R8A8_UNORM;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03205");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    attachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+
+    // Mismatched format list
+    attachmentFormat = VK_FORMAT_B8G8R8A8_UNORM;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03205");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    attachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+
+    // Mismatched layer count, multiview disabled
+    framebufferCreateInfo.layers = 2;
+    const char* mismatchedLayersNoMultiviewVuid =
+        multiviewSupported ? "VUID-VkFramebufferCreateInfo-renderPass-03199" : "VUID-VkFramebufferCreateInfo-flags-03200";
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, mismatchedLayersNoMultiviewVuid);
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferCreateInfo.layers = 1;
+
+    // Mismatched width
+    framebufferCreateInfo.width += 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03192");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferCreateInfo.width -= 1;
+
+    // Mismatched height
+    framebufferCreateInfo.height += 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03193");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferCreateInfo.height -= 1;
+
+    vkDestroyRenderPass(m_device->device(), renderPass, nullptr);
+}
+
+TEST_F(VkLayerTest, ImagelessFramebufferAttachmentImageUsageMismatchTests) {
+    TEST_DESCRIPTION("Create an imageless framebuffer with mismatched attachment image usage");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_MAINTENANCE2_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+        return;
+    }
+
+    VkPhysicalDeviceImagelessFramebufferFeaturesKHR physicalDeviceImagelessFramebufferFeatures = {};
+    physicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR;
+    physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer = VK_TRUE;
+    VkPhysicalDeviceFeatures2 physicalDeviceFeatures2 = {};
+    physicalDeviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+    physicalDeviceFeatures2.pNext = &physicalDeviceImagelessFramebufferFeatures;
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &physicalDeviceFeatures2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    uint32_t attachmentWidth = 512;
+    uint32_t attachmentHeight = 512;
+    VkFormat colorAndInputAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+    VkFormat depthStencilAttachmentFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
+
+    VkAttachmentDescription attachmentDescriptions[4] = {};
+    // Color attachment
+    attachmentDescriptions[0].format = colorAndInputAttachmentFormat;
+    attachmentDescriptions[0].samples = VK_SAMPLE_COUNT_4_BIT;
+    attachmentDescriptions[0].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    // Color resolve attachment
+    attachmentDescriptions[1].format = colorAndInputAttachmentFormat;
+    attachmentDescriptions[1].samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescriptions[1].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    // Depth stencil attachment
+    attachmentDescriptions[2].format = depthStencilAttachmentFormat;
+    attachmentDescriptions[2].samples = VK_SAMPLE_COUNT_4_BIT;
+    attachmentDescriptions[2].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    // Input attachment
+    attachmentDescriptions[3].format = colorAndInputAttachmentFormat;
+    attachmentDescriptions[3].samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescriptions[3].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+    VkAttachmentReference colorAttachmentReference = {};
+    colorAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    colorAttachmentReference.attachment = 0;
+    VkAttachmentReference colorResolveAttachmentReference = {};
+    colorResolveAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    colorResolveAttachmentReference.attachment = 1;
+    VkAttachmentReference depthStencilAttachmentReference = {};
+    depthStencilAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    depthStencilAttachmentReference.attachment = 2;
+    VkAttachmentReference inputAttachmentReference = {};
+    inputAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    inputAttachmentReference.attachment = 3;
+    VkSubpassDescription subpassDescription = {};
+    subpassDescription.colorAttachmentCount = 1;
+    subpassDescription.pColorAttachments = &colorAttachmentReference;
+    subpassDescription.pResolveAttachments = &colorResolveAttachmentReference;
+    subpassDescription.pDepthStencilAttachment = &depthStencilAttachmentReference;
+    subpassDescription.inputAttachmentCount = 1;
+    subpassDescription.pInputAttachments = &inputAttachmentReference;
+
+    VkRenderPassCreateInfo renderPassCreateInfo = {};
+    renderPassCreateInfo.attachmentCount = 4;
+    renderPassCreateInfo.subpassCount = 1;
+    renderPassCreateInfo.pSubpasses = &subpassDescription;
+    renderPassCreateInfo.pAttachments = attachmentDescriptions;
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    VkRenderPass renderPass;
+    vkCreateRenderPass(m_device->device(), &renderPassCreateInfo, nullptr, &renderPass);
+
+    VkFramebufferAttachmentImageInfoKHR framebufferAttachmentImageInfos[4] = {};
+    // Color attachment
+    framebufferAttachmentImageInfos[0].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[0].width = attachmentWidth;
+    framebufferAttachmentImageInfos[0].height = attachmentHeight;
+    framebufferAttachmentImageInfos[0].usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[0].layerCount = 1;
+    framebufferAttachmentImageInfos[0].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[0].pViewFormats = &colorAndInputAttachmentFormat;
+    // Color resolve attachment
+    framebufferAttachmentImageInfos[1].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[1].width = attachmentWidth;
+    framebufferAttachmentImageInfos[1].height = attachmentHeight;
+    framebufferAttachmentImageInfos[1].usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[1].layerCount = 1;
+    framebufferAttachmentImageInfos[1].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[1].pViewFormats = &colorAndInputAttachmentFormat;
+    // Depth stencil attachment
+    framebufferAttachmentImageInfos[2].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[2].width = attachmentWidth;
+    framebufferAttachmentImageInfos[2].height = attachmentHeight;
+    framebufferAttachmentImageInfos[2].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[2].layerCount = 1;
+    framebufferAttachmentImageInfos[2].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[2].pViewFormats = &depthStencilAttachmentFormat;
+    // Input attachment
+    framebufferAttachmentImageInfos[3].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[3].width = attachmentWidth;
+    framebufferAttachmentImageInfos[3].height = attachmentHeight;
+    framebufferAttachmentImageInfos[3].usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[3].layerCount = 1;
+    framebufferAttachmentImageInfos[3].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[3].pViewFormats = &colorAndInputAttachmentFormat;
+    VkFramebufferAttachmentsCreateInfoKHR framebufferAttachmentsCreateInfo = {};
+    framebufferAttachmentsCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR;
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 4;
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = framebufferAttachmentImageInfos;
+    VkFramebufferCreateInfo framebufferCreateInfo = {};
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = &framebufferAttachmentsCreateInfo;
+    framebufferCreateInfo.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR;
+    framebufferCreateInfo.width = attachmentWidth;
+    framebufferCreateInfo.height = attachmentHeight;
+    framebufferCreateInfo.layers = 1;
+    framebufferCreateInfo.renderPass = renderPass;
+    framebufferCreateInfo.attachmentCount = 4;
+    VkFramebuffer framebuffer = VK_NULL_HANDLE;
+
+    // Color attachment, mismatched usage
+    framebufferAttachmentImageInfos[0].usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03201");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[0].usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+    // Color resolve attachment, mismatched usage
+    framebufferAttachmentImageInfos[1].usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03201");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[1].usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+
+    // Depth stencil attachment, mismatched usage
+    framebufferAttachmentImageInfos[2].usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03202");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[2].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+
+    // Color attachment, mismatched usage
+    framebufferAttachmentImageInfos[3].usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03204");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[3].usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+
+    vkDestroyRenderPass(m_device->device(), renderPass, nullptr);
+}
+
+TEST_F(VkLayerTest, ImagelessFramebufferAttachmentMultiviewImageLayerCountMismatchTests) {
+    TEST_DESCRIPTION("Create an imageless framebuffer against a multiview-enabled render pass with mismatched layer counts");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_MULTIVIEW_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_MULTIVIEW_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix, VK_KHR_MULTIVIEW_EXTENSION_NAME);
+        return;
+    }
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_MAINTENANCE2_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+        return;
+    }
+
+    VkPhysicalDeviceImagelessFramebufferFeaturesKHR physicalDeviceImagelessFramebufferFeatures = {};
+    physicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR;
+    physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer = VK_TRUE;
+    VkPhysicalDeviceFeatures2 physicalDeviceFeatures2 = {};
+    physicalDeviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+    physicalDeviceFeatures2.pNext = &physicalDeviceImagelessFramebufferFeatures;
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &physicalDeviceFeatures2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    uint32_t attachmentWidth = 512;
+    uint32_t attachmentHeight = 512;
+    VkFormat colorAndInputAttachmentFormat = VK_FORMAT_R8G8B8A8_UNORM;
+    VkFormat depthStencilAttachmentFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
+
+    VkAttachmentDescription attachmentDescriptions[4] = {};
+    // Color attachment
+    attachmentDescriptions[0].format = colorAndInputAttachmentFormat;
+    attachmentDescriptions[0].samples = VK_SAMPLE_COUNT_4_BIT;
+    attachmentDescriptions[0].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    // Color resolve attachment
+    attachmentDescriptions[1].format = colorAndInputAttachmentFormat;
+    attachmentDescriptions[1].samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescriptions[1].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    // Depth stencil attachment
+    attachmentDescriptions[2].format = depthStencilAttachmentFormat;
+    attachmentDescriptions[2].samples = VK_SAMPLE_COUNT_4_BIT;
+    attachmentDescriptions[2].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    // Input attachment
+    attachmentDescriptions[3].format = colorAndInputAttachmentFormat;
+    attachmentDescriptions[3].samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescriptions[3].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+    VkAttachmentReference colorAttachmentReference = {};
+    colorAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    colorAttachmentReference.attachment = 0;
+    VkAttachmentReference colorResolveAttachmentReference = {};
+    colorResolveAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    colorResolveAttachmentReference.attachment = 1;
+    VkAttachmentReference depthStencilAttachmentReference = {};
+    depthStencilAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    depthStencilAttachmentReference.attachment = 2;
+    VkAttachmentReference inputAttachmentReference = {};
+    inputAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    inputAttachmentReference.attachment = 3;
+    VkSubpassDescription subpassDescription = {};
+    subpassDescription.colorAttachmentCount = 1;
+    subpassDescription.pColorAttachments = &colorAttachmentReference;
+    subpassDescription.pResolveAttachments = &colorResolveAttachmentReference;
+    subpassDescription.pDepthStencilAttachment = &depthStencilAttachmentReference;
+    subpassDescription.inputAttachmentCount = 1;
+    subpassDescription.pInputAttachments = &inputAttachmentReference;
+
+    uint32_t viewMask = 0x3u;
+    VkRenderPassMultiviewCreateInfo renderPassMultiviewCreateInfo = {};
+    renderPassMultiviewCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
+    renderPassMultiviewCreateInfo.subpassCount = 1;
+    renderPassMultiviewCreateInfo.pViewMasks = &viewMask;
+    VkRenderPassCreateInfo renderPassCreateInfo = {};
+    renderPassCreateInfo.pNext = &renderPassMultiviewCreateInfo;
+    renderPassCreateInfo.attachmentCount = 4;
+    renderPassCreateInfo.subpassCount = 1;
+    renderPassCreateInfo.pSubpasses = &subpassDescription;
+    renderPassCreateInfo.pAttachments = attachmentDescriptions;
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    VkRenderPass renderPass;
+    vkCreateRenderPass(m_device->device(), &renderPassCreateInfo, nullptr, &renderPass);
+
+    VkFramebufferAttachmentImageInfoKHR framebufferAttachmentImageInfos[4] = {};
+    // Color attachment
+    framebufferAttachmentImageInfos[0].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[0].width = attachmentWidth;
+    framebufferAttachmentImageInfos[0].height = attachmentHeight;
+    framebufferAttachmentImageInfos[0].usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[0].layerCount = 2;
+    framebufferAttachmentImageInfos[0].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[0].pViewFormats = &colorAndInputAttachmentFormat;
+    // Color resolve attachment
+    framebufferAttachmentImageInfos[1].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[1].width = attachmentWidth;
+    framebufferAttachmentImageInfos[1].height = attachmentHeight;
+    framebufferAttachmentImageInfos[1].usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[1].layerCount = 2;
+    framebufferAttachmentImageInfos[1].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[1].pViewFormats = &colorAndInputAttachmentFormat;
+    // Depth stencil attachment
+    framebufferAttachmentImageInfos[2].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[2].width = attachmentWidth;
+    framebufferAttachmentImageInfos[2].height = attachmentHeight;
+    framebufferAttachmentImageInfos[2].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[2].layerCount = 2;
+    framebufferAttachmentImageInfos[2].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[2].pViewFormats = &depthStencilAttachmentFormat;
+    // Input attachment
+    framebufferAttachmentImageInfos[3].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[3].width = attachmentWidth;
+    framebufferAttachmentImageInfos[3].height = attachmentHeight;
+    framebufferAttachmentImageInfos[3].usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[3].layerCount = 2;
+    framebufferAttachmentImageInfos[3].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[3].pViewFormats = &colorAndInputAttachmentFormat;
+    VkFramebufferAttachmentsCreateInfoKHR framebufferAttachmentsCreateInfo = {};
+    framebufferAttachmentsCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR;
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 4;
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = framebufferAttachmentImageInfos;
+    VkFramebufferCreateInfo framebufferCreateInfo = {};
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = &framebufferAttachmentsCreateInfo;
+    framebufferCreateInfo.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR;
+    framebufferCreateInfo.width = attachmentWidth;
+    framebufferCreateInfo.height = attachmentHeight;
+    framebufferCreateInfo.layers = 1;
+    framebufferCreateInfo.renderPass = renderPass;
+    framebufferCreateInfo.attachmentCount = 4;
+    VkFramebuffer framebuffer = VK_NULL_HANDLE;
+
+    // Color attachment, mismatched layer count
+    framebufferAttachmentImageInfos[0].layerCount = 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-renderPass-03198");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[0].layerCount = 2;
+
+    // Color resolve attachment, mismatched layer count
+    framebufferAttachmentImageInfos[1].layerCount = 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-renderPass-03198");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[1].layerCount = 2;
+
+    // Depth stencil attachment, mismatched layer count
+    framebufferAttachmentImageInfos[2].layerCount = 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-renderPass-03198");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[2].layerCount = 2;
+
+    // Input attachment, mismatched layer count
+    framebufferAttachmentImageInfos[3].layerCount = 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-renderPass-03198");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[3].layerCount = 2;
+
+    vkDestroyRenderPass(m_device->device(), renderPass, nullptr);
+}
+
+TEST_F(VkLayerTest, ImagelessFramebufferDepthStencilResolveAttachmentTests) {
+    TEST_DESCRIPTION(
+        "Create an imageless framebuffer against a render pass using depth stencil resolve, with mismatched information");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    bool rp2Supported = CheckCreateRenderPass2Support(this, m_device_extension_names);
+    if (!rp2Supported) {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix, VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME);
+        return;
+    }
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME);
+        return;
+    }
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_KHR_MAINTENANCE2_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME);
+        m_device_extension_names.push_back(VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required device extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME);
+        return;
+    }
+
+    VkPhysicalDeviceImagelessFramebufferFeaturesKHR physicalDeviceImagelessFramebufferFeatures = {};
+    physicalDeviceImagelessFramebufferFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR;
+    physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer = VK_TRUE;
+    VkPhysicalDeviceFeatures2 physicalDeviceFeatures2 = {};
+    physicalDeviceFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+    physicalDeviceFeatures2.pNext = &physicalDeviceImagelessFramebufferFeatures;
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &physicalDeviceFeatures2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    uint32_t attachmentWidth = 512;
+    uint32_t attachmentHeight = 512;
+    VkFormat attachmentFormat = VK_FORMAT_D32_SFLOAT_S8_UINT;
+
+    VkAttachmentDescription2KHR attachmentDescriptions[2] = {};
+    // Depth/stencil attachment
+    attachmentDescriptions[0].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR;
+    attachmentDescriptions[0].format = attachmentFormat;
+    attachmentDescriptions[0].samples = VK_SAMPLE_COUNT_4_BIT;
+    attachmentDescriptions[0].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+    // Depth/stencil resolve attachment
+    attachmentDescriptions[1].sType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR;
+    attachmentDescriptions[1].format = attachmentFormat;
+    attachmentDescriptions[1].samples = VK_SAMPLE_COUNT_1_BIT;
+    attachmentDescriptions[1].finalLayout = VK_IMAGE_LAYOUT_GENERAL;
+
+    VkAttachmentReference2KHR depthStencilAttachmentReference = {};
+    depthStencilAttachmentReference.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR;
+    depthStencilAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    depthStencilAttachmentReference.attachment = 0;
+    VkAttachmentReference2KHR depthStencilResolveAttachmentReference = {};
+    depthStencilResolveAttachmentReference.sType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR;
+    depthStencilResolveAttachmentReference.layout = VK_IMAGE_LAYOUT_GENERAL;
+    depthStencilResolveAttachmentReference.attachment = 1;
+    VkSubpassDescriptionDepthStencilResolveKHR subpassDescriptionDepthStencilResolve = {};
+    subpassDescriptionDepthStencilResolve.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR;
+    subpassDescriptionDepthStencilResolve.pDepthStencilResolveAttachment = &depthStencilResolveAttachmentReference;
+    subpassDescriptionDepthStencilResolve.depthResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR;
+    subpassDescriptionDepthStencilResolve.stencilResolveMode = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR;
+    VkSubpassDescription2KHR subpassDescription = {};
+    subpassDescription.sType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR;
+    subpassDescription.pNext = &subpassDescriptionDepthStencilResolve;
+    subpassDescription.pDepthStencilAttachment = &depthStencilAttachmentReference;
+    subpassDescription.viewMask = 0x3u;
+
+    VkRenderPassCreateInfo2KHR renderPassCreateInfo = {};
+    renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR;
+    renderPassCreateInfo.pNext = nullptr;
+    renderPassCreateInfo.attachmentCount = 2;
+    renderPassCreateInfo.subpassCount = 1;
+    renderPassCreateInfo.pSubpasses = &subpassDescription;
+    renderPassCreateInfo.pAttachments = attachmentDescriptions;
+    VkRenderPass renderPass;
+    PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR =
+        (PFN_vkCreateRenderPass2KHR)vkGetDeviceProcAddr(m_device->device(), "vkCreateRenderPass2KHR");
+    vkCreateRenderPass2KHR(m_device->device(), &renderPassCreateInfo, nullptr, &renderPass);
+
+    VkFramebufferAttachmentImageInfoKHR framebufferAttachmentImageInfos[2] = {};
+    // Depth/stencil attachment
+    framebufferAttachmentImageInfos[0].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[0].width = attachmentWidth;
+    framebufferAttachmentImageInfos[0].height = attachmentHeight;
+    framebufferAttachmentImageInfos[0].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[0].layerCount = 2;
+    framebufferAttachmentImageInfos[0].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[0].pViewFormats = &attachmentFormat;
+    // Depth/stencil resolve attachment
+    framebufferAttachmentImageInfos[1].sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR;
+    framebufferAttachmentImageInfos[1].width = attachmentWidth;
+    framebufferAttachmentImageInfos[1].height = attachmentHeight;
+    framebufferAttachmentImageInfos[1].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+    framebufferAttachmentImageInfos[1].layerCount = 2;
+    framebufferAttachmentImageInfos[1].viewFormatCount = 1;
+    framebufferAttachmentImageInfos[1].pViewFormats = &attachmentFormat;
+    VkFramebufferAttachmentsCreateInfoKHR framebufferAttachmentsCreateInfo = {};
+    framebufferAttachmentsCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR;
+    framebufferAttachmentsCreateInfo.attachmentImageInfoCount = 2;
+    framebufferAttachmentsCreateInfo.pAttachmentImageInfos = framebufferAttachmentImageInfos;
+    VkFramebufferCreateInfo framebufferCreateInfo = {};
+    framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
+    framebufferCreateInfo.pNext = &framebufferAttachmentsCreateInfo;
+    framebufferCreateInfo.flags = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR;
+    framebufferCreateInfo.width = attachmentWidth;
+    framebufferCreateInfo.height = attachmentHeight;
+    framebufferCreateInfo.layers = 1;
+    framebufferCreateInfo.renderPass = renderPass;
+    framebufferCreateInfo.attachmentCount = 2;
+    VkFramebuffer framebuffer = VK_NULL_HANDLE;
+
+    // Color attachment, mismatched layer count
+    framebufferAttachmentImageInfos[0].layerCount = 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-renderPass-03198");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[0].layerCount = 2;
+
+    // Depth resolve attachment, mismatched image usage
+    framebufferAttachmentImageInfos[1].usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-flags-03203");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[1].usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
+
+    // Depth resolve attachment, mismatched layer count
+    framebufferAttachmentImageInfos[1].layerCount = 1;
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkFramebufferCreateInfo-renderPass-03198");
+    vkCreateFramebuffer(m_device->device(), &framebufferCreateInfo, nullptr, &framebuffer);
+    m_errorMonitor->VerifyFound();
+    if (framebuffer != VK_NULL_HANDLE) {
+        vkDestroyFramebuffer(m_device->device(), framebuffer, nullptr);
+    }
+    framebufferAttachmentImageInfos[1].layerCount = 2;
+
+    vkDestroyRenderPass(m_device->device(), renderPass, nullptr);
+}
diff --git a/tests/vklayertests_others.cpp b/tests/vklayertests_others.cpp
index 5621654f2..f05426976 100644
--- a/tests/vklayertests_others.cpp
+++ b/tests/vklayertests_others.cpp
@@ -128,6 +128,11 @@ TEST_F(VkLayerTest, RequiredParameter) {
     submitInfo.pWaitDstStageMask = &stageFlags;
     vkQueueSubmit(m_device->m_queue, 1, &submitInfo, VK_NULL_HANDLE);
     m_errorMonitor->VerifyFound();
+
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCreateRenderPass-pCreateInfo-parameter");
+    VkRenderPass render_pass;
+    vkCreateRenderPass(device(), nullptr, nullptr, &render_pass);
+    m_errorMonitor->VerifyFound();
 }
 
 TEST_F(VkLayerTest, PnextOnlyStructValidation) {
@@ -926,16 +931,19 @@ TEST_F(VkLayerTest, TemporaryExternalSemaphore) {
     vkQueueSubmit(m_device->m_queue, 4, si, VK_NULL_HANDLE);
     m_errorMonitor->VerifyFound();
 
-    // Wait on the imported semaphore twice in vkQueueBindSparse, the second wait should be an error
-    VkBindSparseInfo bi[] = {
-        {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 1, &export_semaphore},
-        {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 1, &import_semaphore, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr},
-        {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 1, &export_semaphore},
-        {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 1, &import_semaphore, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr},
-    };
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "has no way to be signaled");
-    vkQueueBindSparse(m_device->m_queue, 4, bi, VK_NULL_HANDLE);
-    m_errorMonitor->VerifyFound();
+    auto index = m_device->graphics_queue_node_index_;
+    if (m_device->queue_props[index].queueFlags & VK_QUEUE_SPARSE_BINDING_BIT) {
+        // Wait on the imported semaphore twice in vkQueueBindSparse, the second wait should be an error
+        VkBindSparseInfo bi[] = {
+            {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 1, &export_semaphore},
+            {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 1, &import_semaphore, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr},
+            {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 1, &export_semaphore},
+            {VK_STRUCTURE_TYPE_BIND_SPARSE_INFO, nullptr, 1, &import_semaphore, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr},
+        };
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "has no way to be signaled");
+        vkQueueBindSparse(m_device->m_queue, 4, bi, VK_NULL_HANDLE);
+        m_errorMonitor->VerifyFound();
+    }
 
     // Cleanup
     err = vkQueueWaitIdle(m_device->m_queue);
@@ -4183,6 +4191,252 @@ bool InitFrameworkForRayTracingTest(VkRenderFramework *renderFramework, std::vec
     return true;
 }
 
+TEST_F(VkLayerTest, ValidateGeometryNV) {
+    TEST_DESCRIPTION("Validate acceleration structure geometries.");
+    if (!InitFrameworkForRayTracingTest(this, m_instance_extension_names, m_device_extension_names, m_errorMonitor)) {
+        return;
+    }
+
+    VkBufferObj vbo;
+    vbo.init(*m_device, 1024, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+             VK_BUFFER_USAGE_RAY_TRACING_BIT_NV);
+
+    VkBufferObj ibo;
+    ibo.init(*m_device, 1024, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+             VK_BUFFER_USAGE_RAY_TRACING_BIT_NV);
+
+    VkBufferObj tbo;
+    tbo.init(*m_device, 1024, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+             VK_BUFFER_USAGE_RAY_TRACING_BIT_NV);
+
+    VkBufferObj aabbbo;
+    aabbbo.init(*m_device, 1024, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
+                VK_BUFFER_USAGE_RAY_TRACING_BIT_NV);
+
+    VkBufferCreateInfo unbound_buffer_ci = {};
+    unbound_buffer_ci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    unbound_buffer_ci.size = 1024;
+    unbound_buffer_ci.usage = VK_BUFFER_USAGE_RAY_TRACING_BIT_NV;
+    VkBufferObj unbound_buffer;
+    unbound_buffer.init_no_mem(*m_device, unbound_buffer_ci);
+
+    const std::vector<float> vertices = {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f};
+    const std::vector<uint32_t> indicies = {0, 1, 2};
+    const std::vector<float> aabbs = {0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f};
+    const std::vector<float> transforms = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f};
+
+    uint8_t *mapped_vbo_buffer_data = (uint8_t *)vbo.memory().map();
+    std::memcpy(mapped_vbo_buffer_data, (uint8_t *)vertices.data(), sizeof(float) * vertices.size());
+    vbo.memory().unmap();
+
+    uint8_t *mapped_ibo_buffer_data = (uint8_t *)ibo.memory().map();
+    std::memcpy(mapped_ibo_buffer_data, (uint8_t *)indicies.data(), sizeof(uint32_t) * indicies.size());
+    ibo.memory().unmap();
+
+    uint8_t *mapped_tbo_buffer_data = (uint8_t *)tbo.memory().map();
+    std::memcpy(mapped_tbo_buffer_data, (uint8_t *)transforms.data(), sizeof(float) * transforms.size());
+    tbo.memory().unmap();
+
+    uint8_t *mapped_aabbbo_buffer_data = (uint8_t *)aabbbo.memory().map();
+    std::memcpy(mapped_aabbbo_buffer_data, (uint8_t *)aabbs.data(), sizeof(float) * aabbs.size());
+    aabbbo.memory().unmap();
+
+    VkGeometryNV valid_geometry_triangles = {};
+    valid_geometry_triangles.sType = VK_STRUCTURE_TYPE_GEOMETRY_NV;
+    valid_geometry_triangles.geometryType = VK_GEOMETRY_TYPE_TRIANGLES_NV;
+    valid_geometry_triangles.geometry.triangles.sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV;
+    valid_geometry_triangles.geometry.triangles.vertexData = vbo.handle();
+    valid_geometry_triangles.geometry.triangles.vertexOffset = 0;
+    valid_geometry_triangles.geometry.triangles.vertexCount = 3;
+    valid_geometry_triangles.geometry.triangles.vertexStride = 12;
+    valid_geometry_triangles.geometry.triangles.vertexFormat = VK_FORMAT_R32G32B32_SFLOAT;
+    valid_geometry_triangles.geometry.triangles.indexData = ibo.handle();
+    valid_geometry_triangles.geometry.triangles.indexOffset = 0;
+    valid_geometry_triangles.geometry.triangles.indexCount = 3;
+    valid_geometry_triangles.geometry.triangles.indexType = VK_INDEX_TYPE_UINT32;
+    valid_geometry_triangles.geometry.triangles.transformData = tbo.handle();
+    valid_geometry_triangles.geometry.triangles.transformOffset = 0;
+    valid_geometry_triangles.geometry.aabbs = {};
+    valid_geometry_triangles.geometry.aabbs.sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV;
+
+    VkGeometryNV valid_geometry_aabbs = {};
+    valid_geometry_aabbs.sType = VK_STRUCTURE_TYPE_GEOMETRY_NV;
+    valid_geometry_aabbs.geometryType = VK_GEOMETRY_TYPE_AABBS_NV;
+    valid_geometry_aabbs.geometry.triangles = {};
+    valid_geometry_aabbs.geometry.triangles.sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV;
+    valid_geometry_aabbs.geometry.aabbs = {};
+    valid_geometry_aabbs.geometry.aabbs.sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV;
+    valid_geometry_aabbs.geometry.aabbs.aabbData = aabbbo.handle();
+    valid_geometry_aabbs.geometry.aabbs.numAABBs = 1;
+    valid_geometry_aabbs.geometry.aabbs.offset = 0;
+    valid_geometry_aabbs.geometry.aabbs.stride = 24;
+
+    PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV = reinterpret_cast<PFN_vkCreateAccelerationStructureNV>(
+        vkGetDeviceProcAddr(m_device->handle(), "vkCreateAccelerationStructureNV"));
+    assert(vkCreateAccelerationStructureNV != nullptr);
+
+    const auto GetCreateInfo = [](const VkGeometryNV &geometry) {
+        VkAccelerationStructureCreateInfoNV as_create_info = {};
+        as_create_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
+        as_create_info.info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV;
+        as_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
+        as_create_info.info.instanceCount = 0;
+        as_create_info.info.geometryCount = 1;
+        as_create_info.info.pGeometries = &geometry;
+        return as_create_info;
+    };
+
+    VkAccelerationStructureNV as;
+
+    // Invalid vertex format.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.vertexFormat = VK_FORMAT_R64_UINT;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-vertexFormat-02430");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid vertex offset - not multiple of component size.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.vertexOffset = 1;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-vertexOffset-02429");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid vertex offset - bigger than buffer.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.vertexOffset = 12 * 1024;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-vertexOffset-02428");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid vertex buffer - no such buffer.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.vertexData = VkBuffer(123456789);
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-vertexData-parameter");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid vertex buffer - no memory bound.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.vertexData = unbound_buffer.handle();
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-vertexOffset-02428");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+
+    // Invalid index offset - not multiple of index size.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.indexOffset = 1;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-indexOffset-02432");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid index offset - bigger than buffer.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.indexOffset = 2048;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-indexOffset-02431");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid index count - must be 0 if type is VK_INDEX_TYPE_NONE_NV.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.indexType = VK_INDEX_TYPE_NONE_NV;
+        geometry.geometry.triangles.indexData = VK_NULL_HANDLE;
+        geometry.geometry.triangles.indexCount = 1;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-indexCount-02436");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid index data - must be VK_NULL_HANDLE if type is VK_INDEX_TYPE_NONE_NV.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.indexType = VK_INDEX_TYPE_NONE_NV;
+        geometry.geometry.triangles.indexData = ibo.handle();
+        geometry.geometry.triangles.indexCount = 0;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-indexData-02434");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+
+    // Invalid transform offset - not multiple of 16.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.transformOffset = 1;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-transformOffset-02438");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid transform offset - bigger than buffer.
+    {
+        VkGeometryNV geometry = valid_geometry_triangles;
+        geometry.geometry.triangles.transformOffset = 2048;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryTrianglesNV-transformOffset-02437");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+
+    // Invalid aabb offset - not multiple of 8.
+    {
+        VkGeometryNV geometry = valid_geometry_aabbs;
+        geometry.geometry.aabbs.offset = 1;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryAABBNV-offset-02440");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid aabb offset - bigger than buffer.
+    {
+        VkGeometryNV geometry = valid_geometry_aabbs;
+        geometry.geometry.aabbs.offset = 8 * 1024;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryAABBNV-offset-02439");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+    // Invalid aabb stride - not multiple of 8.
+    {
+        VkGeometryNV geometry = valid_geometry_aabbs;
+        geometry.geometry.aabbs.stride = 1;
+
+        VkAccelerationStructureCreateInfoNV as_create_info = GetCreateInfo(geometry);
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkGeometryAABBNV-stride-02441");
+        vkCreateAccelerationStructureNV(m_device->handle(), &as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+}
+
 void GetSimpleGeometryForAccelerationStructureTests(const VkDeviceObj &device, VkBufferObj *vbo, VkBufferObj *ibo,
                                                     VkGeometryNV *geometry) {
     vbo->init(device, 1024);
@@ -4196,7 +4450,7 @@ void GetSimpleGeometryForAccelerationStructureTests(const VkDeviceObj &device, V
     geometry->geometry.triangles.vertexOffset = 0;
     geometry->geometry.triangles.vertexCount = 3;
     geometry->geometry.triangles.vertexStride = 12;
-    geometry->geometry.triangles.vertexFormat = VK_FORMAT_R32G32B32A32_SFLOAT;
+    geometry->geometry.triangles.vertexFormat = VK_FORMAT_R32G32B32_SFLOAT;
     geometry->geometry.triangles.indexData = ibo->handle();
     geometry->geometry.triangles.indexOffset = 0;
     geometry->geometry.triangles.indexCount = 3;
@@ -4226,51 +4480,89 @@ TEST_F(VkLayerTest, ValidateCreateAccelerationStructureNV) {
     as_create_info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV;
     as_create_info.info.sType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV;
 
-    // Top level can not have geometry
-    VkAccelerationStructureCreateInfoNV bad_top_level_create_info = as_create_info;
-    bad_top_level_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV;
-    bad_top_level_create_info.info.instanceCount = 0;
-    bad_top_level_create_info.info.geometryCount = 1;
-    bad_top_level_create_info.info.pGeometries = &geometry;
     VkAccelerationStructureNV as = VK_NULL_HANDLE;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkAccelerationStructureInfoNV-type-02425");
-    vkCreateAccelerationStructureNV(m_device->handle(), &bad_top_level_create_info, nullptr, &as);
-    m_errorMonitor->VerifyFound();
+
+    // Top level can not have geometry
+    {
+        VkAccelerationStructureCreateInfoNV bad_top_level_create_info = as_create_info;
+        bad_top_level_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV;
+        bad_top_level_create_info.info.instanceCount = 0;
+        bad_top_level_create_info.info.geometryCount = 1;
+        bad_top_level_create_info.info.pGeometries = &geometry;
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkAccelerationStructureInfoNV-type-02425");
+        vkCreateAccelerationStructureNV(m_device->handle(), &bad_top_level_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
 
     // Bot level can not have instances
-    VkAccelerationStructureCreateInfoNV bad_bot_level_create_info = as_create_info;
-    bad_bot_level_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
-    bad_bot_level_create_info.info.instanceCount = 1;
-    bad_bot_level_create_info.info.geometryCount = 0;
-    bad_bot_level_create_info.info.pGeometries = nullptr;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkAccelerationStructureInfoNV-type-02426");
-    vkCreateAccelerationStructureNV(m_device->handle(), &bad_bot_level_create_info, nullptr, &as);
-    m_errorMonitor->VerifyFound();
+    {
+        VkAccelerationStructureCreateInfoNV bad_bot_level_create_info = as_create_info;
+        bad_bot_level_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
+        bad_bot_level_create_info.info.instanceCount = 1;
+        bad_bot_level_create_info.info.geometryCount = 0;
+        bad_bot_level_create_info.info.pGeometries = nullptr;
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkAccelerationStructureInfoNV-type-02426");
+        vkCreateAccelerationStructureNV(m_device->handle(), &bad_bot_level_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
 
     // Can not prefer both fast trace and fast build
-    VkAccelerationStructureCreateInfoNV bad_flags_level_create_info = as_create_info;
-    bad_flags_level_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
-    bad_flags_level_create_info.info.instanceCount = 0;
-    bad_flags_level_create_info.info.geometryCount = 1;
-    bad_flags_level_create_info.info.pGeometries = &geometry;
-    bad_flags_level_create_info.info.flags =
-        VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV | VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkAccelerationStructureInfoNV-flags-02592");
-    vkCreateAccelerationStructureNV(m_device->handle(), &bad_flags_level_create_info, nullptr, &as);
-    m_errorMonitor->VerifyFound();
+    {
+        VkAccelerationStructureCreateInfoNV bad_flags_level_create_info = as_create_info;
+        bad_flags_level_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
+        bad_flags_level_create_info.info.instanceCount = 0;
+        bad_flags_level_create_info.info.geometryCount = 1;
+        bad_flags_level_create_info.info.pGeometries = &geometry;
+        bad_flags_level_create_info.info.flags =
+            VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV | VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV;
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-VkAccelerationStructureInfoNV-flags-02592");
+        vkCreateAccelerationStructureNV(m_device->handle(), &bad_flags_level_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
 
     // Can not have geometry or instance for compacting
-    VkAccelerationStructureCreateInfoNV bad_compacting_as_create_info = as_create_info;
-    bad_compacting_as_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
-    bad_compacting_as_create_info.info.instanceCount = 0;
-    bad_compacting_as_create_info.info.geometryCount = 1;
-    bad_compacting_as_create_info.info.pGeometries = &geometry;
-    bad_compacting_as_create_info.info.flags = 0;
-    bad_compacting_as_create_info.compactedSize = 1024;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
-                                         "VUID-VkAccelerationStructureCreateInfoNV-compactedSize-02421");
-    vkCreateAccelerationStructureNV(m_device->handle(), &bad_compacting_as_create_info, nullptr, &as);
-    m_errorMonitor->VerifyFound();
+    {
+        VkAccelerationStructureCreateInfoNV bad_compacting_as_create_info = as_create_info;
+        bad_compacting_as_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
+        bad_compacting_as_create_info.info.instanceCount = 0;
+        bad_compacting_as_create_info.info.geometryCount = 1;
+        bad_compacting_as_create_info.info.pGeometries = &geometry;
+        bad_compacting_as_create_info.info.flags = 0;
+        bad_compacting_as_create_info.compactedSize = 1024;
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                             "VUID-VkAccelerationStructureCreateInfoNV-compactedSize-02421");
+        vkCreateAccelerationStructureNV(m_device->handle(), &bad_compacting_as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
+
+    // Can not mix different geometry types into single bottom level acceleration structure
+    {
+        VkGeometryNV aabb_geometry = {};
+        aabb_geometry.sType = VK_STRUCTURE_TYPE_GEOMETRY_NV;
+        aabb_geometry.geometryType = VK_GEOMETRY_TYPE_AABBS_NV;
+        aabb_geometry.geometry.triangles.sType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV;
+        aabb_geometry.geometry.aabbs = {};
+        aabb_geometry.geometry.aabbs.sType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV;
+        // Buffer contents do not matter for this test.
+        aabb_geometry.geometry.aabbs.aabbData = geometry.geometry.triangles.vertexData;
+        aabb_geometry.geometry.aabbs.numAABBs = 1;
+        aabb_geometry.geometry.aabbs.offset = 0;
+        aabb_geometry.geometry.aabbs.stride = 24;
+
+        std::vector<VkGeometryNV> geometries = {geometry, aabb_geometry};
+
+        VkAccelerationStructureCreateInfoNV mix_geometry_types_as_create_info = as_create_info;
+        mix_geometry_types_as_create_info.info.type = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV;
+        mix_geometry_types_as_create_info.info.instanceCount = 0;
+        mix_geometry_types_as_create_info.info.geometryCount = static_cast<uint32_t>(geometries.size());
+        mix_geometry_types_as_create_info.info.pGeometries = geometries.data();
+        mix_geometry_types_as_create_info.info.flags = 0;
+
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                             "UNASSIGNED-VkAccelerationStructureInfoNV-pGeometries-XXXX");
+        vkCreateAccelerationStructureNV(m_device->handle(), &mix_geometry_types_as_create_info, nullptr, &as);
+        m_errorMonitor->VerifyFound();
+    }
 }
 
 TEST_F(VkLayerTest, ValidateBindAccelerationStructureNV) {
@@ -4569,13 +4861,29 @@ TEST_F(VkLayerTest, ValidateGetAccelerationStructureHandleNV) {
     bot_level_as_create_info.info.geometryCount = 1;
     bot_level_as_create_info.info.pGeometries = &geometry;
 
-    VkAccelerationStructureObj bot_level_as(*m_device, bot_level_as_create_info);
-    m_errorMonitor->VerifyNotFound();
+    // Not enough space for the handle
+    {
+        VkAccelerationStructureObj bot_level_as(*m_device, bot_level_as_create_info);
+        m_errorMonitor->VerifyNotFound();
 
-    uint64_t handle = 0;
-    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkGetAccelerationStructureHandleNV-dataSize-02240");
-    vkGetAccelerationStructureHandleNV(m_device->handle(), bot_level_as.handle(), sizeof(uint8_t), &handle);
-    m_errorMonitor->VerifyFound();
+        uint64_t handle = 0;
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                             "VUID-vkGetAccelerationStructureHandleNV-dataSize-02240");
+        vkGetAccelerationStructureHandleNV(m_device->handle(), bot_level_as.handle(), sizeof(uint8_t), &handle);
+        m_errorMonitor->VerifyFound();
+    }
+
+    // No memory bound to acceleration structure
+    {
+        VkAccelerationStructureObj bot_level_as(*m_device, bot_level_as_create_info, /*init_memory=*/false);
+        m_errorMonitor->VerifyNotFound();
+
+        uint64_t handle = 0;
+        m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                             "UNASSIGNED-vkGetAccelerationStructureHandleNV-accelerationStructure-XXXX");
+        vkGetAccelerationStructureHandleNV(m_device->handle(), bot_level_as.handle(), sizeof(uint64_t), &handle);
+        m_errorMonitor->VerifyFound();
+    }
 }
 
 TEST_F(VkLayerTest, ValidateCmdCopyAccelerationStructureNV) {
diff --git a/tests/vklayertests_pipeline_shader.cpp b/tests/vklayertests_pipeline_shader.cpp
index 0bcbcbc35..daa6df0f5 100644
--- a/tests/vklayertests_pipeline_shader.cpp
+++ b/tests/vklayertests_pipeline_shader.cpp
@@ -28,7 +28,7 @@
 #include "layer_validation_tests.h"
 
 TEST_F(VkLayerTest, PSOPolygonModeInvalid) {
-    TEST_DESCRIPTION("Attempt to use a non-solid polygon fill mode in a pipeline when this feature is not enabled.");
+    TEST_DESCRIPTION("Attempt to use invalid polygon fill modes.");
     VkPhysicalDeviceFeatures device_features = {};
     device_features.fillModeNonSolid = VK_FALSE;
     // The sacrificial device object
@@ -43,17 +43,23 @@ TEST_F(VkLayerTest, PSOPolygonModeInvalid) {
 
     auto set_polygonMode = [&](CreatePipelineHelper &helper) { helper.rs_state_ci_ = rs_ci; };
 
-    // Set polygonMode to unsupported value POINT, should fail
+    // Set polygonMode to POINT while the non-solid fill mode feature is disabled.
     // Introduce failure by setting unsupported polygon mode
     rs_ci.polygonMode = VK_POLYGON_MODE_POINT;
     CreatePipelineHelper::OneshotTest(*this, set_polygonMode, VK_DEBUG_REPORT_ERROR_BIT_EXT,
                                       "polygonMode cannot be VK_POLYGON_MODE_POINT or VK_POLYGON_MODE_LINE");
 
-    // Try again with polygonMode=LINE, should fail
+    // Set polygonMode to LINE while the non-solid fill mode feature is disabled.
     // Introduce failure by setting unsupported polygon mode
     rs_ci.polygonMode = VK_POLYGON_MODE_LINE;
     CreatePipelineHelper::OneshotTest(*this, set_polygonMode, VK_DEBUG_REPORT_ERROR_BIT_EXT,
                                       "polygonMode cannot be VK_POLYGON_MODE_POINT or VK_POLYGON_MODE_LINE");
+
+    // Set polygonMode to FILL_RECTANGLE_NV while the extension is not enabled.
+    // Introduce failure by setting unsupported polygon mode
+    rs_ci.polygonMode = VK_POLYGON_MODE_FILL_RECTANGLE_NV;
+    CreatePipelineHelper::OneshotTest(*this, set_polygonMode, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                      "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01414");
 }
 
 TEST_F(VkLayerTest, PipelineNotBound) {
@@ -2829,7 +2835,7 @@ TEST_F(VkLayerTest, CreatePipelineCheckShaderBadSpecialization) {
 
     const auto set_info = [&](CreatePipelineHelper &helper) {
         helper.shader_stages_ = {helper.vs_->GetStageCreateInfo(), fs.GetStageCreateInfo()};
-        helper.shader_stages_[0].pSpecializationInfo = &specialization_info;
+        helper.shader_stages_[1].pSpecializationInfo = &specialization_info;
     };
     CreatePipelineHelper::OneshotTest(
         *this, set_info, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
@@ -4100,7 +4106,7 @@ TEST_F(VkLayerTest, CreatePipelineExceedMaxGeometryInputOutputComponents) {
 
         // Finalize
         int max_vertices = overflow ? (m_device->props.limits.maxGeometryTotalOutputComponents / maxGeomOutComp + 1) : 1;
-        gsSourceStr += "layout(points, max_vertices = " + std::to_string(max_vertices) +
+        gsSourceStr += "layout(triangle_strip, max_vertices = " + std::to_string(max_vertices) +
                        ") out;\n"
                        "\n"
                        "void main(){\n"
@@ -4196,7 +4202,7 @@ TEST_F(VkLayerTest, CreatePipelineExceedMaxGeometryInstanceVertexCount) {
                OpMemoryModel Logical GLSL450
                OpEntryPoint Geometry %main "main"
                OpExecutionMode %main InputPoints
-               OpExecutionMode %main OutputPoints
+               OpExecutionMode %main OutputTriangleStrip
                )";
         if (overflow) {
             gsSourceStr += "OpExecutionMode %main Invocations " +
@@ -5539,3 +5545,210 @@ TEST_F(VkLayerTest, CreatePipelineCheckFragmentShaderInterlockEnabled) {
     pipe.CreateVKPipeline(pipeline_layout.handle(), render_pass.handle());
     m_errorMonitor->VerifyFound();
 }
+
+TEST_F(VkLayerTest, CreatePipelineCheckDemoteToHelperInvocation) {
+    TEST_DESCRIPTION("Create a pipeline requiring the demote to helper invocation feature which has not enabled on the device.");
+
+    ASSERT_NO_FATAL_FAILURE(Init());
+
+    std::vector<const char *> device_extension_names;
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME)) {
+        // Note: we intentionally do not add the required extension to the device extension list.
+        //       in order to create the error below
+    } else {
+        // We skip this test if the extension is not supported by the driver as in some cases this will cause
+        // the vkCreateShaderModule to fail without generating an error message
+        printf("%s Extension %s is not supported.\n", kSkipPrefix, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME);
+        return;
+    }
+
+    auto features = m_device->phy().features();
+
+    // Disable the demote to helper invocation feature.
+    auto demote_features = lvl_init_struct<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>();
+    demote_features.shaderDemoteToHelperInvocation = VK_FALSE;
+
+    VkDeviceObj test_device(0, gpu(), device_extension_names, &features, &demote_features);
+
+    char const *fsSource =
+        "#version 450\n"
+        "#extension GL_EXT_demote_to_helper_invocation : require\n"
+        "void main(){\n"
+        "    demote;\n"
+        "}\n";
+
+    VkShaderObj vs(&test_device, bindStateVertShaderText, VK_SHADER_STAGE_VERTEX_BIT, this);
+    VkShaderObj fs(&test_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
+
+    VkRenderpassObj render_pass(&test_device);
+
+    VkPipelineObj pipe(&test_device);
+    pipe.AddDefaultColorAttachment();
+    pipe.AddShader(&vs);
+    pipe.AddShader(&fs);
+
+    const VkPipelineLayoutObj pipeline_layout(&test_device);
+
+    m_errorMonitor->SetDesiredFailureMsg(
+        VK_DEBUG_REPORT_ERROR_BIT_EXT,
+        "Shader requires VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::shaderDemoteToHelperInvocation but is not "
+        "enabled on "
+        "the device");
+    m_errorMonitor->SetDesiredFailureMsg(
+        VK_DEBUG_REPORT_ERROR_BIT_EXT,
+        "Shader requires extension VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT::shaderDemoteToHelperInvocation but "
+        "is not "
+        "enabled on the device");
+    pipe.CreateVKPipeline(pipeline_layout.handle(), render_pass.handle());
+    m_errorMonitor->VerifyFound();
+}
+
+TEST_F(VkLayerTest, CreatePipelineCheckLineRasterization) {
+    TEST_DESCRIPTION("Test VK_EXT_line_rasterization state against feature enables.");
+
+    if (InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
+        m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    } else {
+        printf("%s Did not find required instance extension %s; skipped.\n", kSkipPrefix,
+               VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+    std::array<const char *, 1> required_device_extensions = {{VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME}};
+    for (auto device_extension : required_device_extensions) {
+        if (DeviceExtensionSupported(gpu(), nullptr, device_extension)) {
+            m_device_extension_names.push_back(device_extension);
+        } else {
+            printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, device_extension);
+            return;
+        }
+    }
+
+    PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
+        (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
+    ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
+
+    auto line_rasterization_features = lvl_init_struct<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
+    auto features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&line_rasterization_features);
+    vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
+
+    line_rasterization_features.rectangularLines = VK_FALSE;
+    line_rasterization_features.bresenhamLines = VK_FALSE;
+    line_rasterization_features.smoothLines = VK_FALSE;
+    line_rasterization_features.stippledRectangularLines = VK_FALSE;
+    line_rasterization_features.stippledBresenhamLines = VK_FALSE;
+    line_rasterization_features.stippledSmoothLines = VK_FALSE;
+
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT));
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    CreatePipelineHelper::OneshotTest(
+        *this,
+        [&](CreatePipelineHelper &helper) {
+            helper.line_state_ci_.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT;
+            helper.pipe_ms_state_ci_.alphaToCoverageEnable = VK_TRUE;
+        },
+        VK_DEBUG_REPORT_ERROR_BIT_EXT,
+        std::vector<const char *>{"VUID-VkGraphicsPipelineCreateInfo-lineRasterizationMode-02766",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769"});
+
+    CreatePipelineHelper::OneshotTest(
+        *this,
+        [&](CreatePipelineHelper &helper) {
+            helper.line_state_ci_.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT;
+            helper.line_state_ci_.stippledLineEnable = VK_TRUE;
+        },
+        VK_DEBUG_REPORT_ERROR_BIT_EXT,
+        std::vector<const char *>{"VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02769",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02772"});
+
+    CreatePipelineHelper::OneshotTest(
+        *this,
+        [&](CreatePipelineHelper &helper) {
+            helper.line_state_ci_.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT;
+            helper.line_state_ci_.stippledLineEnable = VK_TRUE;
+        },
+        VK_DEBUG_REPORT_ERROR_BIT_EXT,
+        std::vector<const char *>{"VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02768",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02771"});
+
+    CreatePipelineHelper::OneshotTest(
+        *this,
+        [&](CreatePipelineHelper &helper) {
+            helper.line_state_ci_.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT;
+            helper.line_state_ci_.stippledLineEnable = VK_TRUE;
+        },
+        VK_DEBUG_REPORT_ERROR_BIT_EXT,
+        std::vector<const char *>{"VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-lineRasterizationMode-02770",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02773"});
+
+    CreatePipelineHelper::OneshotTest(
+        *this,
+        [&](CreatePipelineHelper &helper) {
+            helper.line_state_ci_.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;
+            helper.line_state_ci_.stippledLineEnable = VK_TRUE;
+        },
+        VK_DEBUG_REPORT_ERROR_BIT_EXT,
+        std::vector<const char *>{"VUID-VkGraphicsPipelineCreateInfo-stippledLineEnable-02767",
+                                  "VUID-VkPipelineRasterizationLineStateCreateInfoEXT-stippledLineEnable-02774"});
+
+    PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT =
+        (PFN_vkCmdSetLineStippleEXT)vkGetDeviceProcAddr(m_device->device(), "vkCmdSetLineStippleEXT");
+    ASSERT_TRUE(vkCmdSetLineStippleEXT != nullptr);
+
+    m_commandBuffer->begin();
+    m_errorMonitor->SetDesiredFailureMsg(VK_DEBUG_REPORT_ERROR_BIT_EXT, "VUID-vkCmdSetLineStippleEXT-lineStippleFactor-02776");
+    vkCmdSetLineStippleEXT(m_commandBuffer->handle(), 0, 0);
+    m_errorMonitor->VerifyFound();
+    vkCmdSetLineStippleEXT(m_commandBuffer->handle(), 1, 1);
+    m_errorMonitor->VerifyFound();
+}
+
+TEST_F(VkLayerTest, FillRectangleNV) {
+    TEST_DESCRIPTION("Verify VK_NV_fill_rectangle");
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    VkPhysicalDeviceFeatures device_features = {};
+    ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&device_features));
+
+    // Disable non-solid fill modes to make sure that the usage of VK_POLYGON_MODE_LINE and
+    // VK_POLYGON_MODE_POINT will cause an error when the VK_NV_fill_rectangle extension is enabled.
+    device_features.fillModeNonSolid = VK_FALSE;
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_NV_FILL_RECTANGLE_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_NV_FILL_RECTANGLE_EXTENSION_NAME);
+    } else {
+        printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_NV_FILL_RECTANGLE_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState(&device_features));
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    VkPolygonMode polygon_mode = VK_POLYGON_MODE_LINE;
+
+    auto set_polygon_mode = [&polygon_mode](CreatePipelineHelper &helper) { helper.rs_state_ci_.polygonMode = polygon_mode; };
+
+    // Set unsupported polygon mode VK_POLYGON_MODE_LINE
+    CreatePipelineHelper::OneshotTest(*this, set_polygon_mode, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                      "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", false);
+
+    // Set unsupported polygon mode VK_POLYGON_MODE_POINT
+    polygon_mode = VK_POLYGON_MODE_POINT;
+    CreatePipelineHelper::OneshotTest(*this, set_polygon_mode, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                      "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", false);
+
+    // Set supported polygon mode VK_POLYGON_MODE_FILL
+    polygon_mode = VK_POLYGON_MODE_FILL;
+    CreatePipelineHelper::OneshotTest(*this, set_polygon_mode, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                      "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", true);
+
+    // Set supported polygon mode VK_POLYGON_MODE_FILL_RECTANGLE_NV
+    polygon_mode = VK_POLYGON_MODE_FILL_RECTANGLE_NV;
+    CreatePipelineHelper::OneshotTest(*this, set_polygon_mode, VK_DEBUG_REPORT_ERROR_BIT_EXT,
+                                      "VUID-VkPipelineRasterizationStateCreateInfo-polygonMode-01507", true);
+}
diff --git a/tests/vkpositivelayertests.cpp b/tests/vkpositivelayertests.cpp
index 18f1880b9..610301ed5 100644
--- a/tests/vkpositivelayertests.cpp
+++ b/tests/vkpositivelayertests.cpp
@@ -5543,6 +5543,167 @@ TEST_F(VkPositiveLayerTest, CreateDescriptorSetBindingWithIgnoredSamplers) {
         m_errorMonitor->VerifyNotFound();
     }
 }
+TEST_F(VkPositiveLayerTest, GpuValidationInlineUniformBlock) {
+    TEST_DESCRIPTION("GPU validation: Make sure inline uniform blocks don't generate false validation errors");
+    m_errorMonitor->ExpectSuccess();
+    VkValidationFeatureEnableEXT enables[] = {VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT};
+    VkValidationFeaturesEXT features = {};
+    features.sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT;
+    features.enabledValidationFeatureCount = 1;
+    features.pEnabledValidationFeatures = enables;
+    bool descriptor_indexing = CheckDescriptorIndexingSupportAndInitFramework(this, m_instance_extension_names,
+                                                                              m_device_extension_names, &features, m_errorMonitor);
+    if (DeviceIsMockICD() || DeviceSimulation()) {
+        printf("%s Test not supported by MockICD, skipping tests\n", kSkipPrefix);
+        return;
+    }
+    VkPhysicalDeviceFeatures2KHR features2 = {};
+    auto indexing_features = lvl_init_struct<VkPhysicalDeviceDescriptorIndexingFeaturesEXT>();
+    auto inline_uniform_block_features = lvl_init_struct<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(&indexing_features);
+    bool inline_uniform_block = DeviceExtensionSupported(gpu(), nullptr, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME);
+    if (!(descriptor_indexing && inline_uniform_block)) {
+        printf("Descriptor indexing and/or inline uniform block not supported Skipping test\n");
+        return;
+    }
+    m_device_extension_names.push_back(VK_KHR_MAINTENANCE1_EXTENSION_NAME);
+    m_device_extension_names.push_back(VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME);
+    PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR =
+        (PFN_vkGetPhysicalDeviceFeatures2KHR)vkGetInstanceProcAddr(instance(), "vkGetPhysicalDeviceFeatures2KHR");
+    ASSERT_TRUE(vkGetPhysicalDeviceFeatures2KHR != nullptr);
+
+    features2 = lvl_init_struct<VkPhysicalDeviceFeatures2KHR>(&inline_uniform_block_features);
+    vkGetPhysicalDeviceFeatures2KHR(gpu(), &features2);
+    if (!indexing_features.descriptorBindingPartiallyBound || !inline_uniform_block_features.inlineUniformBlock) {
+        printf("Not all features supported, skipping test\n");
+        return;
+    }
+    auto inline_uniform_props = lvl_init_struct<VkPhysicalDeviceInlineUniformBlockPropertiesEXT>();
+    auto prop2 = lvl_init_struct<VkPhysicalDeviceProperties2KHR>(&inline_uniform_props);
+    vkGetPhysicalDeviceProperties2(gpu(), &prop2);
+
+    VkCommandPoolCreateFlags pool_flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+    ASSERT_NO_FATAL_FAILURE(InitState(nullptr, &features2, pool_flags));
+    if (m_device->props.apiVersion < VK_API_VERSION_1_1) {
+        printf("%s GPU-Assisted validation test requires Vulkan 1.1+.\n", kSkipPrefix);
+        return;
+    }
+    auto c_queue = m_device->GetDefaultComputeQueue();
+    if (nullptr == c_queue) {
+        printf("Compute not supported, skipping test\n");
+        return;
+    }
+
+    uint32_t qfi = 0;
+    VkBufferCreateInfo bci = {};
+    bci.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    bci.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+    bci.size = 4;
+    bci.queueFamilyIndexCount = 1;
+    bci.pQueueFamilyIndices = &qfi;
+    VkBufferObj buffer0;
+    VkMemoryPropertyFlags mem_props = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+    buffer0.init(*m_device, bci, mem_props);
+
+    VkDescriptorBindingFlagsEXT ds_binding_flags[2] = {};
+    ds_binding_flags[1] = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT;
+    VkDescriptorSetLayoutBindingFlagsCreateInfoEXT layout_createinfo_binding_flags[1] = {};
+    layout_createinfo_binding_flags[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT;
+    layout_createinfo_binding_flags[0].pNext = NULL;
+    layout_createinfo_binding_flags[0].bindingCount = 2;
+    layout_createinfo_binding_flags[0].pBindingFlags = ds_binding_flags;
+
+    OneOffDescriptorSet descriptor_set(m_device,
+                                       {
+                                           {0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_ALL, nullptr},
+                                           {1, VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT, 20, VK_SHADER_STAGE_ALL,
+                                            nullptr},  // 16 bytes for ivec4, 4 more for int
+                                       },
+                                       0, layout_createinfo_binding_flags, 0);
+    const VkPipelineLayoutObj pipeline_layout(m_device, {&descriptor_set.layout_});
+
+    VkDescriptorBufferInfo buffer_info[1] = {};
+    buffer_info[0].buffer = buffer0.handle();
+    buffer_info[0].offset = 0;
+    buffer_info[0].range = sizeof(uint32_t);
+
+    const uint32_t test_data = 0xdeadca7;
+    VkWriteDescriptorSetInlineUniformBlockEXT write_inline_uniform = {};
+    write_inline_uniform.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT;
+    write_inline_uniform.dataSize = 4;
+    write_inline_uniform.pData = &test_data;
+
+    VkWriteDescriptorSet descriptor_writes[2] = {};
+    descriptor_writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptor_writes[0].dstSet = descriptor_set.set_;
+    descriptor_writes[0].dstBinding = 0;
+    descriptor_writes[0].descriptorCount = 1;
+    descriptor_writes[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
+    descriptor_writes[0].pBufferInfo = buffer_info;
+
+    descriptor_writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+    descriptor_writes[1].dstSet = descriptor_set.set_;
+    descriptor_writes[1].dstBinding = 1;
+    descriptor_writes[1].dstArrayElement = 16;  // Skip first 16 bytes (dummy)
+    descriptor_writes[1].descriptorCount = 4;   // Write 4 bytes to val
+    descriptor_writes[1].descriptorType = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT;
+    descriptor_writes[1].pNext = &write_inline_uniform;
+    vkUpdateDescriptorSets(m_device->device(), 2, descriptor_writes, 0, NULL);
+
+    char const *csSource =
+        "#version 450\n"
+        "#extension GL_EXT_nonuniform_qualifier : enable\n "
+        "layout(set = 0, binding = 0) buffer StorageBuffer { uint index; } u_index;"
+        "layout(set = 0, binding = 1) uniform inlineubodef { ivec4 dummy; int val; } inlineubo;\n"
+
+        "void main() {\n"
+        "    u_index.index = inlineubo.val;\n"
+        "}\n";
+
+    auto shader_module = new VkShaderObj(m_device, csSource, VK_SHADER_STAGE_COMPUTE_BIT, this);
+
+    VkPipelineShaderStageCreateInfo stage;
+    stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
+    stage.pNext = nullptr;
+    stage.flags = 0;
+    stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
+    stage.module = shader_module->handle();
+    stage.pName = "main";
+    stage.pSpecializationInfo = nullptr;
+
+    // CreateComputePipelines
+    VkComputePipelineCreateInfo pipeline_info = {};
+    pipeline_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
+    pipeline_info.pNext = nullptr;
+    pipeline_info.flags = 0;
+    pipeline_info.layout = pipeline_layout.handle();
+    pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
+    pipeline_info.basePipelineIndex = -1;
+    pipeline_info.stage = stage;
+
+    VkPipeline c_pipeline;
+    vkCreateComputePipelines(device(), VK_NULL_HANDLE, 1, &pipeline_info, nullptr, &c_pipeline);
+
+    m_commandBuffer->begin();
+    vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_COMPUTE, c_pipeline);
+    vkCmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_COMPUTE, pipeline_layout.handle(), 0, 1,
+                            &descriptor_set.set_, 0, nullptr);
+    vkCmdDispatch(m_commandBuffer->handle(), 1, 1, 1);
+    m_commandBuffer->end();
+
+    VkSubmitInfo submit_info = {};
+    submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
+    submit_info.commandBufferCount = 1;
+    submit_info.pCommandBuffers = &m_commandBuffer->handle();
+    vkQueueSubmit(c_queue->handle(), 1, &submit_info, VK_NULL_HANDLE);
+    vkQueueWaitIdle(m_device->m_queue);
+    m_errorMonitor->VerifyNotFound();
+    vkDestroyPipeline(m_device->handle(), c_pipeline, NULL);
+    vkDestroyShaderModule(m_device->handle(), shader_module->handle(), NULL);
+
+    uint32_t *data = (uint32_t *)buffer0.memory().map();
+    ASSERT_TRUE(*data = test_data);
+    buffer0.memory().unmap();
+}
 
 TEST_F(VkPositiveLayerTest, Maintenance1Tests) {
     TEST_DESCRIPTION("Validate various special cases for the Maintenance1_KHR extension");
@@ -7721,3 +7882,469 @@ TEST_F(VkPositiveLayerTest, TransferImageToSwapchainDeviceGroup) {
     vkDestroyImage(m_device->device(), peer_image, NULL);
     DestroySwapchain();
 }
+
+TEST_F(VkPositiveLayerTest, RenderPassValidStages) {
+    TEST_DESCRIPTION("Create render pass with valid stages");
+
+    bool rp2_supported = InstanceExtensionSupported(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+    if (rp2_supported) m_instance_extension_names.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+    if (rp2_supported) rp2_supported = CheckCreateRenderPass2Support(this, m_device_extension_names);
+    ASSERT_NO_FATAL_FAILURE(InitState());
+
+    VkSubpassDescription sci[2] = {};
+    sci[0].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    sci[1].pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+
+    VkSubpassDependency dependency = {};
+    // to be filled later by tests
+
+    VkRenderPassCreateInfo rpci = {};
+    rpci.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
+    rpci.subpassCount = 2;
+    rpci.pSubpasses = sci;
+    rpci.dependencyCount = 1;
+    rpci.pDependencies = &dependency;
+
+    const VkPipelineStageFlags kGraphicsStages =
+        VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT |
+        VK_PIPELINE_STAGE_VERTEX_INPUT_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
+        VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
+        VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
+
+    dependency.srcSubpass = 0;
+    dependency.dstSubpass = 1;
+    dependency.srcStageMask = kGraphicsStages;
+    dependency.dstStageMask = kGraphicsStages;
+    PositiveTestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported);
+
+    dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
+    dependency.dstSubpass = 0;
+    dependency.srcStageMask = kGraphicsStages | VK_PIPELINE_STAGE_HOST_BIT;
+    dependency.dstStageMask = kGraphicsStages;
+    PositiveTestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported);
+
+    dependency.srcSubpass = 0;
+    dependency.dstSubpass = VK_SUBPASS_EXTERNAL;
+    dependency.srcStageMask = kGraphicsStages;
+    dependency.dstStageMask = VK_PIPELINE_STAGE_HOST_BIT;
+    PositiveTestRenderPassCreate(m_errorMonitor, m_device->device(), &rpci, rp2_supported);
+}
+
+TEST_F(VkPositiveLayerTest, SampleMaskOverrideCoverageNV) {
+    TEST_DESCRIPTION("Test to validate VK_NV_sample_mask_override_coverage");
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME);
+    } else {
+        printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+
+    const char vs_src[] = R"(
+        #version 450
+        layout(location=0) out vec4  fragColor;
+
+        const vec2 pos[3] = { vec2( 0.0f, -0.5f),
+                              vec2( 0.5f,  0.5f),
+                              vec2(-0.5f,  0.5f)
+                            };
+        void main()
+        {
+            gl_Position = vec4(pos[gl_VertexIndex % 3], 0.0f, 1.0f);
+            fragColor = vec4(0.0f, 1.0f, 0.0f, 1.0f);
+        })";
+
+    const char fs_src[] = R"(
+        #version 450
+        #extension GL_NV_sample_mask_override_coverage : require
+
+        layout(location = 0) in  vec4 fragColor;
+        layout(location = 0) out vec4 outColor;
+
+        layout(override_coverage) out int gl_SampleMask[];
+
+        void main()
+        {
+            gl_SampleMask[0] = 0xff;
+            outColor = fragColor;
+        })";
+
+    m_errorMonitor->ExpectSuccess();
+
+    const VkSampleCountFlagBits sampleCount = VK_SAMPLE_COUNT_8_BIT;
+
+    VkAttachmentDescription cAttachment = {};
+    cAttachment.format = VK_FORMAT_B8G8R8A8_UNORM;
+    cAttachment.samples = sampleCount;
+    cAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+    cAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+    cAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
+    cAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
+    cAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    cAttachment.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+    VkAttachmentReference cAttachRef = {};
+    cAttachRef.attachment = 0;
+    cAttachRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+
+    VkSubpassDescription subpass = {};
+    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    subpass.colorAttachmentCount = 1;
+    subpass.pColorAttachments = &cAttachRef;
+
+    VkRenderPassCreateInfo rpci = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO};
+    rpci.attachmentCount = 1;
+    rpci.pAttachments = &cAttachment;
+    rpci.subpassCount = 1;
+    rpci.pSubpasses = &subpass;
+
+    VkRenderPass rp;
+    vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
+
+    const VkPipelineLayoutObj pl(m_device);
+
+    VkSampleMask sampleMask = 0x01;
+    VkPipelineMultisampleStateCreateInfo msaa = {VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
+    msaa.rasterizationSamples = sampleCount;
+    msaa.sampleShadingEnable = VK_FALSE;
+    msaa.pSampleMask = &sampleMask;
+
+    VkPipelineObj pipe(m_device);
+    pipe.AddDefaultColorAttachment();
+    pipe.SetMSAA(&msaa);
+
+    VkShaderObj vs(m_device, vs_src, VK_SHADER_STAGE_VERTEX_BIT, this);
+    pipe.AddShader(&vs);
+
+    VkShaderObj fs(m_device, fs_src, VK_SHADER_STAGE_FRAGMENT_BIT, this);
+    pipe.AddShader(&fs);
+
+    // Create pipeline and make sure that the usage of NV_sample_mask_override_coverage
+    // in the fragment shader does not cause any errors.
+    pipe.CreateVKPipeline(pl.handle(), rp);
+
+    vkDestroyRenderPass(m_device->device(), rp, nullptr);
+
+    m_errorMonitor->VerifyNotFound();
+}
+
+TEST_F(VkPositiveLayerTest, TestRasterizationDiscardEnableTrue) {
+    TEST_DESCRIPTION("Ensure it doesn't crash and trigger error msg when rasterizerDiscardEnable = true");
+    ASSERT_NO_FATAL_FAILURE(Init());
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    VkAttachmentDescription att[1] = {{}};
+    att[0].format = VK_FORMAT_R8G8B8A8_UNORM;
+    att[0].samples = VK_SAMPLE_COUNT_4_BIT;
+    att[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+    att[0].finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
+    VkAttachmentReference cr = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
+    VkSubpassDescription sp = {};
+    sp.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
+    sp.colorAttachmentCount = 1;
+    sp.pColorAttachments = &cr;
+    VkRenderPassCreateInfo rpi = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO};
+    rpi.attachmentCount = 1;
+    rpi.pAttachments = att;
+    rpi.subpassCount = 1;
+    rpi.pSubpasses = &sp;
+    VkRenderPass rp;
+    vkCreateRenderPass(m_device->device(), &rpi, nullptr, &rp);
+
+    CreatePipelineHelper pipe(*this);
+    pipe.InitInfo();
+    pipe.gp_ci_.pViewportState = nullptr;
+    pipe.gp_ci_.pMultisampleState = nullptr;
+    pipe.gp_ci_.pDepthStencilState = nullptr;
+    pipe.gp_ci_.pColorBlendState = nullptr;
+    pipe.gp_ci_.renderPass = rp;
+
+    m_errorMonitor->ExpectSuccess();
+    // Skip the test in NexusPlayer. The driver crashes when pViewportState, pMultisampleState, pDepthStencilState, pColorBlendState
+    // are NULL.
+    pipe.rs_state_ci_.rasterizerDiscardEnable = VK_TRUE;
+    pipe.InitState();
+    pipe.CreateGraphicsPipeline();
+    m_errorMonitor->VerifyNotFound();
+    vkDestroyRenderPass(m_device->device(), rp, nullptr);
+}
+
+TEST_F(VkPositiveLayerTest, TestSamplerDataForCombinedImageSampler) {
+    TEST_DESCRIPTION("Shader code uses sampler data for CombinedImageSampler");
+    ASSERT_NO_FATAL_FAILURE(Init());
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    const std::string fsSource = R"(
+                   OpCapability Shader
+                   OpMemoryModel Logical GLSL450
+                   OpEntryPoint Fragment %main "main"
+                   OpExecutionMode %main OriginUpperLeft
+
+                   OpDecorate %InputData DescriptorSet 0
+                   OpDecorate %InputData Binding 0
+                   OpDecorate %SamplerData DescriptorSet 0
+                   OpDecorate %SamplerData Binding 0
+
+               %void = OpTypeVoid
+                %f32 = OpTypeFloat 32
+              %Image = OpTypeImage %f32 2D 0 0 0 1 Rgba32f
+           %ImagePtr = OpTypePointer UniformConstant %Image
+          %InputData = OpVariable %ImagePtr UniformConstant
+            %Sampler = OpTypeSampler
+         %SamplerPtr = OpTypePointer UniformConstant %Sampler
+        %SamplerData = OpVariable %SamplerPtr UniformConstant
+       %SampledImage = OpTypeSampledImage %Image
+
+               %func = OpTypeFunction %void
+               %main = OpFunction %void None %func
+                 %40 = OpLabel
+           %call_smp = OpLoad %Sampler %SamplerData
+                   OpReturn
+                   OpFunctionEnd)";
+
+    VkShaderObj fs(m_device, fsSource, VK_SHADER_STAGE_FRAGMENT_BIT, this);
+
+    CreatePipelineHelper pipe(*this);
+    pipe.InitInfo();
+    pipe.dsl_bindings_ = {
+        {0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_ALL, nullptr},
+    };
+    pipe.shader_stages_ = {fs.GetStageCreateInfo(), pipe.vs_->GetStageCreateInfo()};
+    pipe.InitState();
+    pipe.CreateGraphicsPipeline();
+
+    VkImageObj image(m_device);
+    image.Init(32, 32, 1, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_TILING_OPTIMAL, 0);
+    VkImageView view = image.targetView(VK_FORMAT_R8G8B8A8_UNORM);
+
+    VkSamplerCreateInfo sampler_ci = SafeSaneSamplerCreateInfo();
+    VkSampler sampler;
+    vkCreateSampler(m_device->device(), &sampler_ci, nullptr, &sampler);
+
+    uint32_t qfi = 0;
+    VkBufferCreateInfo buffer_create_info = {};
+    buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
+    buffer_create_info.size = 1024;
+    buffer_create_info.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+    buffer_create_info.queueFamilyIndexCount = 1;
+    buffer_create_info.pQueueFamilyIndices = &qfi;
+
+    VkBufferObj buffer;
+    buffer.init(*m_device, buffer_create_info);
+
+    pipe.descriptor_set_->WriteDescriptorImageInfo(0, view, sampler, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);
+    pipe.descriptor_set_->UpdateDescriptorSets();
+
+    m_commandBuffer->begin();
+    m_commandBuffer->BeginRenderPass(m_renderPassBeginInfo);
+    vkCmdBindPipeline(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_);
+    vkCmdBindDescriptorSets(m_commandBuffer->handle(), VK_PIPELINE_BIND_POINT_GRAPHICS, pipe.pipeline_layout_.handle(), 0, 1,
+                            &pipe.descriptor_set_->set_, 0, NULL);
+
+    m_errorMonitor->ExpectSuccess();
+    vkCmdDraw(m_commandBuffer->handle(), 3, 1, 0, 0);
+    m_errorMonitor->VerifyNotFound();
+
+    vkCmdEndRenderPass(m_commandBuffer->handle());
+    m_commandBuffer->end();
+    vkDestroySampler(m_device->device(), sampler, NULL);
+}
+
+TEST_F(VkPositiveLayerTest, NotPointSizeGeometryShaderSuccess) {
+    TEST_DESCRIPTION("Create a pipeline using TOPOLOGY_POINT_LIST, but geometry shader doesn't include PointSize.");
+
+    ASSERT_NO_FATAL_FAILURE(Init());
+
+    if ((!m_device->phy().features().geometryShader)) {
+        printf("%s Device does not support the required geometry shader features; skipped.\n", kSkipPrefix);
+        return;
+    }
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+    ASSERT_NO_FATAL_FAILURE(InitViewport());
+
+    VkShaderObj gs(m_device, bindStateGeomShaderText, VK_SHADER_STAGE_GEOMETRY_BIT, this);
+
+    CreatePipelineHelper pipe(*this);
+    pipe.InitInfo();
+    pipe.shader_stages_ = {pipe.vs_->GetStageCreateInfo(), gs.GetStageCreateInfo(), pipe.fs_->GetStageCreateInfo()};
+    pipe.ia_ci_.topology = VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+    pipe.InitState();
+
+    m_errorMonitor->ExpectSuccess();
+    pipe.CreateGraphicsPipeline();
+    m_errorMonitor->VerifyNotFound();
+}
+
+TEST_F(VkPositiveLayerTest, SubpassWithReadOnlyLayoutWithoutDependency) {
+    TEST_DESCRIPTION("When both subpasses' attachments are the same and layouts are read-only, they don't need dependency.");
+    ASSERT_NO_FATAL_FAILURE(Init());
+
+    auto depth_format = FindSupportedDepthStencilFormat(gpu());
+    if (!depth_format) {
+        printf("%s No Depth + Stencil format found. Skipped.\n", kSkipPrefix);
+        return;
+    }
+
+    // A renderpass with one color attachment.
+    VkAttachmentDescription attachment = {0,
+                                          depth_format,
+                                          VK_SAMPLE_COUNT_1_BIT,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_STORE,
+                                          VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+                                          VK_ATTACHMENT_STORE_OP_DONT_CARE,
+                                          VK_IMAGE_LAYOUT_UNDEFINED,
+                                          VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL};
+    const int size = 2;
+    std::array<VkAttachmentDescription, size> attachments = {attachment, attachment};
+
+    VkAttachmentReference att_ref_depth_stencil = {0, VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL};
+
+    std::array<VkSubpassDescription, size> subpasses;
+    subpasses[0] = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, 0, 0, nullptr, nullptr, &att_ref_depth_stencil, 0, nullptr};
+    subpasses[1] = {0, VK_PIPELINE_BIND_POINT_GRAPHICS, 0, 0, 0, nullptr, nullptr, &att_ref_depth_stencil, 0, nullptr};
+
+    VkRenderPassCreateInfo rpci = {
+        VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, nullptr, 0, size, attachments.data(), size, subpasses.data(), 0, nullptr};
+
+    VkRenderPass rp;
+    VkResult err = vkCreateRenderPass(m_device->device(), &rpci, nullptr, &rp);
+    ASSERT_VK_SUCCESS(err);
+
+    // A compatible framebuffer.
+    VkImageObj image(m_device);
+    image.Init(32, 32, 1, depth_format, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_TILING_LINEAR, 0);
+    ASSERT_TRUE(image.initialized());
+
+    VkImageViewCreateInfo ivci = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
+                                  nullptr,
+                                  0,
+                                  image.handle(),
+                                  VK_IMAGE_VIEW_TYPE_2D,
+                                  depth_format,
+                                  {VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
+                                   VK_COMPONENT_SWIZZLE_IDENTITY},
+                                  {VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT, 0, 1, 0, 1}};
+
+    VkImageView view;
+    err = vkCreateImageView(m_device->device(), &ivci, nullptr, &view);
+    ASSERT_VK_SUCCESS(err);
+    std::array<VkImageView, size> views = {view, view};
+
+    VkFramebufferCreateInfo fci = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, nullptr, 0, rp, size, views.data(), 32, 32, 1};
+    VkFramebuffer fb;
+    err = vkCreateFramebuffer(m_device->device(), &fci, nullptr, &fb);
+    ASSERT_VK_SUCCESS(err);
+
+    VkRenderPassBeginInfo rpbi = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, nullptr, rp, fb, {{0, 0}, {32, 32}}, 0, nullptr};
+    m_commandBuffer->begin();
+    vkCmdBeginRenderPass(m_commandBuffer->handle(), &rpbi, VK_SUBPASS_CONTENTS_INLINE);
+    vkCmdNextSubpass(m_commandBuffer->handle(), VK_SUBPASS_CONTENTS_INLINE);
+    vkCmdEndRenderPass(m_commandBuffer->handle());
+    m_commandBuffer->end();
+
+    vkDestroyFramebuffer(m_device->device(), fb, nullptr);
+    vkDestroyRenderPass(m_device->device(), rp, nullptr);
+    vkDestroyImageView(m_device->device(), view, nullptr);
+}
+
+TEST_F(VkPositiveLayerTest, GeometryShaderPassthroughNV) {
+    TEST_DESCRIPTION("Test to validate VK_NV_geometry_shader_passthrough");
+
+    ASSERT_NO_FATAL_FAILURE(InitFramework(myDbgFunc, m_errorMonitor));
+
+    VkPhysicalDeviceFeatures available_features = {};
+    ASSERT_NO_FATAL_FAILURE(GetPhysicalDeviceFeatures(&available_features));
+
+    if (!available_features.geometryShader) {
+        printf("%s VkPhysicalDeviceFeatures::geometryShader is not supported, skipping test\n", kSkipPrefix);
+        return;
+    }
+
+    if (DeviceExtensionSupported(gpu(), nullptr, VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME)) {
+        m_device_extension_names.push_back(VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME);
+    } else {
+        printf("%s %s Extension not supported, skipping tests\n", kSkipPrefix, VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME);
+        return;
+    }
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+    ASSERT_NO_FATAL_FAILURE(InitRenderTarget());
+
+    const char vs_src[] = R"(
+        #version 450
+
+        out gl_PerVertex {
+            vec4 gl_Position;
+        };
+
+        layout(location = 0) out ColorBlock {vec4 vertexColor;};
+
+        const vec2 positions[3] = { vec2( 0.0f, -0.5f),
+                                    vec2( 0.5f,  0.5f),
+                                    vec2(-0.5f,  0.5f)
+                                  };
+
+        const vec4 colors[3] = { vec4(1.0f, 0.0f, 0.0f, 1.0f),
+                                 vec4(0.0f, 1.0f, 0.0f, 1.0f),
+                                 vec4(0.0f, 0.0f, 1.0f, 1.0f)
+                               };
+        void main()
+        {
+            vertexColor = colors[gl_VertexIndex % 3];
+            gl_Position = vec4(positions[gl_VertexIndex % 3], 0.0, 1.0);
+        })";
+
+    const char gs_src[] = R"(
+        #version 450
+        #extension GL_NV_geometry_shader_passthrough: require
+
+        layout(triangles) in;
+        layout(triangle_strip, max_vertices = 3) out;
+
+        layout(passthrough) in gl_PerVertex {vec4 gl_Position;};
+        layout(location = 0, passthrough) in ColorBlock {vec4 vertexColor;};
+
+        void main()
+        {
+           gl_Layer = 0;
+        })";
+
+    const char fs_src[] = R"(
+        #version 450
+
+        layout(location = 0) in ColorBlock {vec4 vertexColor;};
+        layout(location = 0) out vec4 outColor;
+
+        void main() {
+            outColor = vertexColor;
+        })";
+
+    m_errorMonitor->ExpectSuccess();
+
+    const VkPipelineLayoutObj pl(m_device);
+
+    VkPipelineObj pipe(m_device);
+    pipe.AddDefaultColorAttachment();
+
+    VkShaderObj vs(m_device, vs_src, VK_SHADER_STAGE_VERTEX_BIT, this);
+    pipe.AddShader(&vs);
+
+    VkShaderObj gs(m_device, gs_src, VK_SHADER_STAGE_GEOMETRY_BIT, this);
+    pipe.AddShader(&gs);
+
+    VkShaderObj fs(m_device, fs_src, VK_SHADER_STAGE_FRAGMENT_BIT, this);
+    pipe.AddShader(&fs);
+
+    // Create pipeline and make sure that the usage of NV_geometry_shader_passthrough
+    // in the fragment shader does not cause any errors.
+    pipe.CreateVKPipeline(pl.handle(), renderPass());
+
+    m_errorMonitor->VerifyNotFound();
+}
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index e16b229dd..f0008355f 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -818,6 +818,12 @@ VkQueueObj *VkDeviceObj::GetDefaultQueue() {
     if (graphics_queues().empty()) return nullptr;
     return graphics_queues()[0];
 }
+
+VkQueueObj *VkDeviceObj::GetDefaultComputeQueue() {
+    if (compute_queues().empty()) return nullptr;
+    return compute_queues()[0];
+}
+
 VkDescriptorSetLayoutObj::VkDescriptorSetLayoutObj(const VkDeviceObj *device,
                                                    const std::vector<VkDescriptorSetLayoutBinding> &descriptor_set_bindings,
                                                    VkDescriptorSetLayoutCreateFlags flags, void *pNext) {
@@ -1604,7 +1610,7 @@ VkPipelineObj::VkPipelineObj(VkDeviceObj *device) {
     m_vp_state.pScissors = nullptr;
 
     m_rs_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
-    m_rs_state.pNext = nullptr;
+    m_rs_state.pNext = &m_line_state;
     m_rs_state.flags = 0;
     m_rs_state.depthClampEnable = VK_FALSE;
     m_rs_state.rasterizerDiscardEnable = VK_FALSE;
@@ -1617,6 +1623,13 @@ VkPipelineObj::VkPipelineObj(VkDeviceObj *device) {
     m_rs_state.depthBiasSlopeFactor = 0.0f;
     m_rs_state.lineWidth = 1.0f;
 
+    m_line_state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT;
+    m_line_state.pNext = nullptr;
+    m_line_state.lineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT;
+    m_line_state.stippledLineEnable = VK_FALSE;
+    m_line_state.lineStippleFactor = 0;
+    m_line_state.lineStipplePattern = 0;
+
     m_ms_state.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
     m_ms_state.pNext = nullptr;
     m_ms_state.flags = 0;
@@ -1692,10 +1705,15 @@ void VkPipelineObj::SetMSAA(const VkPipelineMultisampleStateCreateInfo *ms_state
 
 void VkPipelineObj::SetInputAssembly(const VkPipelineInputAssemblyStateCreateInfo *ia_state) { m_ia_state = *ia_state; }
 
-void VkPipelineObj::SetRasterization(const VkPipelineRasterizationStateCreateInfo *rs_state) { m_rs_state = *rs_state; }
+void VkPipelineObj::SetRasterization(const VkPipelineRasterizationStateCreateInfo *rs_state) {
+    m_rs_state = *rs_state;
+    m_rs_state.pNext = &m_line_state;
+}
 
 void VkPipelineObj::SetTessellation(const VkPipelineTessellationStateCreateInfo *te_state) { m_te_state = te_state; }
 
+void VkPipelineObj::SetLineState(const VkPipelineRasterizationLineStateCreateInfoEXT *line_state) { m_line_state = *line_state; }
+
 void VkPipelineObj::InitGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo *gp_ci) {
     gp_ci->stageCount = m_shaderStages.size();
     gp_ci->pStages = m_shaderStages.size() ? m_shaderStages.data() : nullptr;
@@ -1845,6 +1863,19 @@ void VkCommandBufferObj::ClearDepthStencilImage(VkImage image, VkImageLayout ima
     vkCmdClearDepthStencilImage(handle(), image, imageLayout, pColor, rangeCount, pRanges);
 }
 
+void VkCommandBufferObj::BuildAccelerationStructure(VkAccelerationStructureObj *as, VkBuffer scratchBuffer) {
+    BuildAccelerationStructure(as, scratchBuffer, VK_NULL_HANDLE);
+}
+
+void VkCommandBufferObj::BuildAccelerationStructure(VkAccelerationStructureObj *as, VkBuffer scratchBuffer, VkBuffer instanceData) {
+    PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV =
+        (PFN_vkCmdBuildAccelerationStructureNV)vkGetDeviceProcAddr(as->dev(), "vkCmdBuildAccelerationStructureNV");
+    assert(vkCmdBuildAccelerationStructureNV != nullptr);
+
+    vkCmdBuildAccelerationStructureNV(handle(), &as->info(), instanceData, 0, VK_FALSE, as->handle(), VK_NULL_HANDLE, scratchBuffer,
+                                      0);
+}
+
 void VkCommandBufferObj::PrepareAttachments(const vector<std::unique_ptr<VkImageObj>> &color_atts,
                                             VkDepthStencilObj *depth_stencil_att) {
     for (const auto &color_att : color_atts) {
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 95c6b8538..f6e8d33b6 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -63,6 +63,7 @@ class VkDeviceObj : public vk_testing::Device {
     VkDevice device() { return handle(); }
     void SetDeviceQueue();
     VkQueueObj *GetDefaultQueue();
+    VkQueueObj *GetDefaultComputeQueue();
 
     uint32_t id;
     VkPhysicalDeviceProperties props;
@@ -215,6 +216,8 @@ class VkCommandBufferObj : public vk_testing::CommandBuffer {
                          const VkImageSubresourceRange *pRanges);
     void ClearDepthStencilImage(VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue *pColor,
                                 uint32_t rangeCount, const VkImageSubresourceRange *pRanges);
+    void BuildAccelerationStructure(VkAccelerationStructureObj *as, VkBuffer scratchBuffer);
+    void BuildAccelerationStructure(VkAccelerationStructureObj *as, VkBuffer scratchBuffer, VkBuffer instanceData);
 
    protected:
     VkDeviceObj *m_device;
@@ -449,6 +452,7 @@ class VkPipelineObj : public vk_testing::Pipeline {
     void SetTessellation(const VkPipelineTessellationStateCreateInfo *te_state);
     void SetViewport(const vector<VkViewport> viewports);
     void SetScissor(const vector<VkRect2D> scissors);
+    void SetLineState(const VkPipelineRasterizationLineStateCreateInfoEXT *line_state);
 
     void InitGraphicsPipelineCreateInfo(VkGraphicsPipelineCreateInfo *gp_ci);
 
@@ -464,6 +468,7 @@ class VkPipelineObj : public vk_testing::Pipeline {
     VkPipelineMultisampleStateCreateInfo m_ms_state;
     VkPipelineTessellationStateCreateInfo const *m_te_state;
     VkPipelineDynamicStateCreateInfo m_pd_state;
+    VkPipelineRasterizationLineStateCreateInfoEXT m_line_state;
     vector<VkDynamicState> m_dynamic_state_enables;
     vector<VkViewport> m_viewports;
     vector<VkRect2D> m_scissors;
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 186e0f642..3444c959e 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -669,6 +669,11 @@ void AccelerationStructure::init(const Device &dev, const VkAccelerationStructur
         bind_info.accelerationStructure = handle();
         bind_info.memory = memory_.handle();
         EXPECT(vkBindAccelerationStructureMemoryNV(dev.handle(), 1, &bind_info) == VK_SUCCESS);
+
+        PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV =
+            (PFN_vkGetAccelerationStructureHandleNV)vkGetDeviceProcAddr(dev.handle(), "vkGetAccelerationStructureHandleNV");
+        assert(vkGetAccelerationStructureHandleNV != nullptr);
+        EXPECT(vkGetAccelerationStructureHandleNV(dev.handle(), handle(), sizeof(uint64_t), &opaque_handle_) == VK_SUCCESS);
     }
 }
 
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 6542331a9..d2a65393a 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -388,8 +388,8 @@ class Buffer : public internal::NonDispHandle<VkBuffer> {
     void init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags mem_props);
     void init(const Device &dev, const VkBufferCreateInfo &info) { init(dev, info, 0); }
     void init(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags mem_props,
-              VkBufferUsageFlags usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT) {
-        init(dev, create_info(size, usage), mem_props);
+              VkBufferUsageFlags usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, const std::vector<uint32_t> &queue_families = {}) {
+        init(dev, create_info(size, usage, &queue_families), mem_props);
     }
     void init(const Device &dev, VkDeviceSize size) { init(dev, size, 0); }
     void init_as_src(const Device &dev, VkDeviceSize size, VkMemoryPropertyFlags &reqs,
@@ -569,6 +569,8 @@ class AccelerationStructure : public internal::NonDispHandle<VkAccelerationStruc
     VkMemoryRequirements2 memory_requirements() const;
     VkMemoryRequirements2 build_scratch_memory_requirements() const;
 
+    uint64_t opaque_handle() const { return opaque_handle_; }
+
     const VkAccelerationStructureInfoNV &info() const { return info_; }
 
     const VkDevice &dev() const { return device(); }
@@ -578,6 +580,7 @@ class AccelerationStructure : public internal::NonDispHandle<VkAccelerationStruc
    private:
     VkAccelerationStructureInfoNV info_;
     DeviceMemory memory_;
+    uint64_t opaque_handle_;
 };
 
 class ShaderModule : public internal::NonDispHandle<VkShaderModule> {