Add tests for VK_KHR_image_format_list
[platform/upstream/VK-GL-CTS.git] / external / vulkancts / framework / vulkan / vkStrUtilImpl.inl
index 216c708..4684e83 100644 (file)
@@ -1,38 +1,37 @@
 /* WARNING: This is auto-generated file. Do not modify, since changes will
  * be lost! Modify the generating script instead.
  */
-template<> const char* getTypeName<VkInstance>                                         (void) { return "VkInstance";                                   }
-template<> const char* getTypeName<VkPhysicalDevice>                           (void) { return "VkPhysicalDevice";                             }
-template<> const char* getTypeName<VkDevice>                                           (void) { return "VkDevice";                                             }
-template<> const char* getTypeName<VkQueue>                                            (void) { return "VkQueue";                                              }
-template<> const char* getTypeName<VkSemaphore>                                        (void) { return "VkSemaphore";                                  }
-template<> const char* getTypeName<VkCommandBuffer>                            (void) { return "VkCommandBuffer";                              }
-template<> const char* getTypeName<VkFence>                                            (void) { return "VkFence";                                              }
-template<> const char* getTypeName<VkDeviceMemory>                                     (void) { return "VkDeviceMemory";                               }
-template<> const char* getTypeName<VkBuffer>                                           (void) { return "VkBuffer";                                             }
-template<> const char* getTypeName<VkImage>                                            (void) { return "VkImage";                                              }
-template<> const char* getTypeName<VkEvent>                                            (void) { return "VkEvent";                                              }
-template<> const char* getTypeName<VkQueryPool>                                        (void) { return "VkQueryPool";                                  }
-template<> const char* getTypeName<VkBufferView>                                       (void) { return "VkBufferView";                                 }
-template<> const char* getTypeName<VkImageView>                                        (void) { return "VkImageView";                                  }
-template<> const char* getTypeName<VkShaderModule>                                     (void) { return "VkShaderModule";                               }
-template<> const char* getTypeName<VkPipelineCache>                            (void) { return "VkPipelineCache";                              }
-template<> const char* getTypeName<VkPipelineLayout>                           (void) { return "VkPipelineLayout";                             }
-template<> const char* getTypeName<VkRenderPass>                                       (void) { return "VkRenderPass";                                 }
-template<> const char* getTypeName<VkPipeline>                                         (void) { return "VkPipeline";                                   }
-template<> const char* getTypeName<VkDescriptorSetLayout>                      (void) { return "VkDescriptorSetLayout";                }
-template<> const char* getTypeName<VkSampler>                                          (void) { return "VkSampler";                                    }
-template<> const char* getTypeName<VkDescriptorPool>                           (void) { return "VkDescriptorPool";                             }
-template<> const char* getTypeName<VkDescriptorSet>                            (void) { return "VkDescriptorSet";                              }
-template<> const char* getTypeName<VkFramebuffer>                                      (void) { return "VkFramebuffer";                                }
-template<> const char* getTypeName<VkCommandPool>                                      (void) { return "VkCommandPool";                                }
-template<> const char* getTypeName<VkSurfaceKHR>                                       (void) { return "VkSurfaceKHR";                                 }
-template<> const char* getTypeName<VkSwapchainKHR>                                     (void) { return "VkSwapchainKHR";                               }
-template<> const char* getTypeName<VkDisplayKHR>                                       (void) { return "VkDisplayKHR";                                 }
-template<> const char* getTypeName<VkDisplayModeKHR>                           (void) { return "VkDisplayModeKHR";                             }
-template<> const char* getTypeName<VkDebugReportCallbackEXT>           (void) { return "VkDebugReportCallbackEXT";             }
-template<> const char* getTypeName<VkObjectTableNVX>                           (void) { return "VkObjectTableNVX";                             }
-template<> const char* getTypeName<VkIndirectCommandsLayoutNVX>        (void) { return "VkIndirectCommandsLayoutNVX";  }
+template<> const char* getTypeName<VkInstance>                                         (void) { return "VkInstance";                                           }
+template<> const char* getTypeName<VkPhysicalDevice>                           (void) { return "VkPhysicalDevice";                                     }
+template<> const char* getTypeName<VkDevice>                                           (void) { return "VkDevice";                                                     }
+template<> const char* getTypeName<VkQueue>                                            (void) { return "VkQueue";                                                      }
+template<> const char* getTypeName<VkSemaphore>                                        (void) { return "VkSemaphore";                                          }
+template<> const char* getTypeName<VkCommandBuffer>                            (void) { return "VkCommandBuffer";                                      }
+template<> const char* getTypeName<VkFence>                                            (void) { return "VkFence";                                                      }
+template<> const char* getTypeName<VkDeviceMemory>                                     (void) { return "VkDeviceMemory";                                       }
+template<> const char* getTypeName<VkBuffer>                                           (void) { return "VkBuffer";                                                     }
+template<> const char* getTypeName<VkImage>                                            (void) { return "VkImage";                                                      }
+template<> const char* getTypeName<VkEvent>                                            (void) { return "VkEvent";                                                      }
+template<> const char* getTypeName<VkQueryPool>                                        (void) { return "VkQueryPool";                                          }
+template<> const char* getTypeName<VkBufferView>                                       (void) { return "VkBufferView";                                         }
+template<> const char* getTypeName<VkImageView>                                        (void) { return "VkImageView";                                          }
+template<> const char* getTypeName<VkShaderModule>                                     (void) { return "VkShaderModule";                                       }
+template<> const char* getTypeName<VkPipelineCache>                            (void) { return "VkPipelineCache";                                      }
+template<> const char* getTypeName<VkPipelineLayout>                           (void) { return "VkPipelineLayout";                                     }
+template<> const char* getTypeName<VkRenderPass>                                       (void) { return "VkRenderPass";                                         }
+template<> const char* getTypeName<VkPipeline>                                         (void) { return "VkPipeline";                                           }
+template<> const char* getTypeName<VkDescriptorSetLayout>                      (void) { return "VkDescriptorSetLayout";                        }
+template<> const char* getTypeName<VkSampler>                                          (void) { return "VkSampler";                                            }
+template<> const char* getTypeName<VkDescriptorPool>                           (void) { return "VkDescriptorPool";                                     }
+template<> const char* getTypeName<VkDescriptorSet>                            (void) { return "VkDescriptorSet";                                      }
+template<> const char* getTypeName<VkFramebuffer>                                      (void) { return "VkFramebuffer";                                        }
+template<> const char* getTypeName<VkCommandPool>                                      (void) { return "VkCommandPool";                                        }
+template<> const char* getTypeName<VkSurfaceKHR>                                       (void) { return "VkSurfaceKHR";                                         }
+template<> const char* getTypeName<VkSwapchainKHR>                                     (void) { return "VkSwapchainKHR";                                       }
+template<> const char* getTypeName<VkDisplayKHR>                                       (void) { return "VkDisplayKHR";                                         }
+template<> const char* getTypeName<VkDisplayModeKHR>                           (void) { return "VkDisplayModeKHR";                                     }
+template<> const char* getTypeName<VkDescriptorUpdateTemplateKHR>      (void) { return "VkDescriptorUpdateTemplateKHR";        }
+template<> const char* getTypeName<VkDebugReportCallbackEXT>           (void) { return "VkDebugReportCallbackEXT";                     }
 
 namespace pt
 {
@@ -66,32 +65,34 @@ const char* getResultName (VkResult value)
 {
        switch (value)
        {
-               case VK_SUCCESS:                                                return "VK_SUCCESS";
-               case VK_NOT_READY:                                              return "VK_NOT_READY";
-               case VK_TIMEOUT:                                                return "VK_TIMEOUT";
-               case VK_EVENT_SET:                                              return "VK_EVENT_SET";
-               case VK_EVENT_RESET:                                    return "VK_EVENT_RESET";
-               case VK_INCOMPLETE:                                             return "VK_INCOMPLETE";
-               case VK_ERROR_OUT_OF_HOST_MEMORY:               return "VK_ERROR_OUT_OF_HOST_MEMORY";
-               case VK_ERROR_OUT_OF_DEVICE_MEMORY:             return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
-               case VK_ERROR_INITIALIZATION_FAILED:    return "VK_ERROR_INITIALIZATION_FAILED";
-               case VK_ERROR_DEVICE_LOST:                              return "VK_ERROR_DEVICE_LOST";
-               case VK_ERROR_MEMORY_MAP_FAILED:                return "VK_ERROR_MEMORY_MAP_FAILED";
-               case VK_ERROR_LAYER_NOT_PRESENT:                return "VK_ERROR_LAYER_NOT_PRESENT";
-               case VK_ERROR_EXTENSION_NOT_PRESENT:    return "VK_ERROR_EXTENSION_NOT_PRESENT";
-               case VK_ERROR_FEATURE_NOT_PRESENT:              return "VK_ERROR_FEATURE_NOT_PRESENT";
-               case VK_ERROR_INCOMPATIBLE_DRIVER:              return "VK_ERROR_INCOMPATIBLE_DRIVER";
-               case VK_ERROR_TOO_MANY_OBJECTS:                 return "VK_ERROR_TOO_MANY_OBJECTS";
-               case VK_ERROR_FORMAT_NOT_SUPPORTED:             return "VK_ERROR_FORMAT_NOT_SUPPORTED";
-               case VK_ERROR_FRAGMENTED_POOL:                  return "VK_ERROR_FRAGMENTED_POOL";
-               case VK_ERROR_SURFACE_LOST_KHR:                 return "VK_ERROR_SURFACE_LOST_KHR";
-               case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
-               case VK_SUBOPTIMAL_KHR:                                 return "VK_SUBOPTIMAL_KHR";
-               case VK_ERROR_OUT_OF_DATE_KHR:                  return "VK_ERROR_OUT_OF_DATE_KHR";
-               case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
-               case VK_ERROR_VALIDATION_FAILED_EXT:    return "VK_ERROR_VALIDATION_FAILED_EXT";
-               case VK_ERROR_INVALID_SHADER_NV:                return "VK_ERROR_INVALID_SHADER_NV";
-               default:                                                                return DE_NULL;
+               case VK_SUCCESS:                                                        return "VK_SUCCESS";
+               case VK_NOT_READY:                                                      return "VK_NOT_READY";
+               case VK_TIMEOUT:                                                        return "VK_TIMEOUT";
+               case VK_EVENT_SET:                                                      return "VK_EVENT_SET";
+               case VK_EVENT_RESET:                                            return "VK_EVENT_RESET";
+               case VK_INCOMPLETE:                                                     return "VK_INCOMPLETE";
+               case VK_ERROR_OUT_OF_HOST_MEMORY:                       return "VK_ERROR_OUT_OF_HOST_MEMORY";
+               case VK_ERROR_OUT_OF_DEVICE_MEMORY:                     return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
+               case VK_ERROR_INITIALIZATION_FAILED:            return "VK_ERROR_INITIALIZATION_FAILED";
+               case VK_ERROR_DEVICE_LOST:                                      return "VK_ERROR_DEVICE_LOST";
+               case VK_ERROR_MEMORY_MAP_FAILED:                        return "VK_ERROR_MEMORY_MAP_FAILED";
+               case VK_ERROR_LAYER_NOT_PRESENT:                        return "VK_ERROR_LAYER_NOT_PRESENT";
+               case VK_ERROR_EXTENSION_NOT_PRESENT:            return "VK_ERROR_EXTENSION_NOT_PRESENT";
+               case VK_ERROR_FEATURE_NOT_PRESENT:                      return "VK_ERROR_FEATURE_NOT_PRESENT";
+               case VK_ERROR_INCOMPATIBLE_DRIVER:                      return "VK_ERROR_INCOMPATIBLE_DRIVER";
+               case VK_ERROR_TOO_MANY_OBJECTS:                         return "VK_ERROR_TOO_MANY_OBJECTS";
+               case VK_ERROR_FORMAT_NOT_SUPPORTED:                     return "VK_ERROR_FORMAT_NOT_SUPPORTED";
+               case VK_ERROR_FRAGMENTED_POOL:                          return "VK_ERROR_FRAGMENTED_POOL";
+               case VK_ERROR_SURFACE_LOST_KHR:                         return "VK_ERROR_SURFACE_LOST_KHR";
+               case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:         return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
+               case VK_SUBOPTIMAL_KHR:                                         return "VK_SUBOPTIMAL_KHR";
+               case VK_ERROR_OUT_OF_DATE_KHR:                          return "VK_ERROR_OUT_OF_DATE_KHR";
+               case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:         return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
+               case VK_ERROR_VALIDATION_FAILED_EXT:            return "VK_ERROR_VALIDATION_FAILED_EXT";
+               case VK_ERROR_INVALID_SHADER_NV:                        return "VK_ERROR_INVALID_SHADER_NV";
+               case VK_ERROR_OUT_OF_POOL_MEMORY_KHR:           return "VK_ERROR_OUT_OF_POOL_MEMORY_KHR";
+               case VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR:      return "VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR";
+               default:                                                                        return DE_NULL;
        }
 }
 
@@ -99,87 +100,137 @@ const char* getStructureTypeName (VkStructureType value)
 {
        switch (value)
        {
-               case VK_STRUCTURE_TYPE_APPLICATION_INFO:                                                                                return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
-               case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:                                                                    return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:                                                                return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:                                                                              return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_SUBMIT_INFO:                                                                                             return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
-               case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:                                                                    return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
-               case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:                                                                             return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
-               case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:                                                                                return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO";
-               case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:                                                                               return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:                                                                   return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:                                                                               return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:                                                                  return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:                                                                              return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:                                                                 return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:                                                                               return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:                                                                  return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:                                                               return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:                                                              return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:                                               return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:                                 return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO";
-               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_TESSELLATION_STATE_CREATE_INFO:                                 return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:                                             return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:                                return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:                                  return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:                                return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO";
-               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_DYNAMIC_STATE_CREATE_INFO:                                              return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:                                                   return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:                                                    return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:                                                             return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:                                                                             return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:                                               return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:                                                             return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:                                                    return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO";
-               case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:                                                                    return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET";
-               case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:                                                                             return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET";
-               case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:                                                                 return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:                                                                 return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:                                                                return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:                                                    return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
-               case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:                                                 return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
-               case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:                                                               return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
-               case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:                                                                  return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
-               case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:                                                                   return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
-               case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:                                                                    return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
-               case VK_STRUCTURE_TYPE_MEMORY_BARRIER:                                                                                  return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
-               case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:                                                             return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:                                                               return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
-               case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:                                                               return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:                                                                                return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
-               case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:                                                    return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:                                                 return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:                                                                return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
-               case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:                                                    return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:                                                             return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:                                                 return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR:                                                             return "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:                                                 return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:                                                   return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
-               case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:                                   return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
-               case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD:    return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD";
-               case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT:                                               return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT";
-               case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT:                                                return "VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT";
-               case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT:                                                    return "VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT";
-               case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV:                               return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV";
-               case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV:                              return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV";
-               case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV:                    return "VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV";
-               case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV:                                    return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV";
-               case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV:                                                  return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV";
-               case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV:                                              return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV";
-               case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV:                                              return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV";
-               case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV:                               return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV";
-               case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT:                                                                    return "VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT";
-               case VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX:                                                    return "VK_STRUCTURE_TYPE_OBJECT_TABLE_CREATE_INFO_NVX";
-               case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX:                                return "VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NVX";
-               case VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX:                                                   return "VK_STRUCTURE_TYPE_CMD_PROCESS_COMMANDS_INFO_NVX";
-               case VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX:                                 return "VK_STRUCTURE_TYPE_CMD_RESERVE_SPACE_FOR_COMMANDS_INFO_NVX";
-               case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX:                                    return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_LIMITS_NVX";
-               case VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX:                                  return "VK_STRUCTURE_TYPE_DEVICE_GENERATED_COMMANDS_FEATURES_NVX";
-               default:                                                                                                                                                return DE_NULL;
+               case VK_STRUCTURE_TYPE_APPLICATION_INFO:                                                                                        return "VK_STRUCTURE_TYPE_APPLICATION_INFO";
+               case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO:                                                                            return "VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO:                                                                        return "VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO:                                                                                      return "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_SUBMIT_INFO:                                                                                                     return "VK_STRUCTURE_TYPE_SUBMIT_INFO";
+               case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO:                                                                            return "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO";
+               case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE:                                                                                     return "VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE";
+               case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO:                                                                                        return "VK_STRUCTURE_TYPE_BIND_SPARSE_INFO";
+               case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO:                                                                                       return "VK_STRUCTURE_TYPE_FENCE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO:                                                                           return "VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO:                                                                                       return "VK_STRUCTURE_TYPE_EVENT_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO:                                                                          return "VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO:                                                                                      return "VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO:                                                                         return "VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO:                                                                                       return "VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO:                                                                          return "VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO:                                                                       return "VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO:                                                                      return "VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:                                                       return "VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO:                                         return "VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO";
+               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_TESSELLATION_STATE_CREATE_INFO:                                         return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO:                                                     return "VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO:                                        return "VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO:                                          return "VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO:                                        return "VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO";
+               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_DYNAMIC_STATE_CREATE_INFO:                                                      return "VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:                                                           return "VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:                                                            return "VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO:                                                                     return "VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO:                                                                                     return "VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO:                                                       return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:                                                                     return "VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO:                                                            return "VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO";
+               case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:                                                                            return "VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET";
+               case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:                                                                                     return "VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET";
+               case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO:                                                                         return "VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO:                                                                         return "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO:                                                                        return "VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO:                                                            return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO";
+               case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO:                                                         return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO";
+               case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO:                                                                       return "VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO";
+               case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO:                                                                          return "VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO";
+               case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER:                                                                           return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER";
+               case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER:                                                                            return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER";
+               case VK_STRUCTURE_TYPE_MEMORY_BARRIER:                                                                                          return "VK_STRUCTURE_TYPE_MEMORY_BARRIER";
+               case VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO:                                                                     return "VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO:                                                                       return "VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO";
+               case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR:                                                                       return "VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR:                                                                                        return "VK_STRUCTURE_TYPE_PRESENT_INFO_KHR";
+               case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR:                                                            return "VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR:                                                         return "VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR:                                                                        return "VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR";
+               case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR:                                                            return "VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR:                                                                     return "VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR:                                                         return "VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR:                                                                     return "VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR:                                                         return "VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR:                                                           return "VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT:                                           return "VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT";
+               case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX:                                           return "VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHX";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX:                                          return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHX";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX:                                        return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHX";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR:                                                          return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR:                                                        return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR";
+               case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR:                                                                         return "VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR";
+               case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR:                                                           return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR:                                         return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR";
+               case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR:                                                           return "VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR:                                         return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR";
+               case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR:                                            return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR:                          return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR:                          return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR:                                            return "VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR:                                        return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR:                                                          return "VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR:                                                       return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR:                                          return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR:                                           return "VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR:                                                         return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR:                                                     return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR:                                                     return "VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR:                                                      return "VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR:                                                        return "VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR:                                                                       return "VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR";
+               case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR:                                                                        return "VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR:                                                                          return "VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR";
+               case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR:                                      return "VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR:                                     return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR:                                                       return "VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR:                                                        return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:                                          return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR:                                          return "VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR:                                                                     return "VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR";
+               case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR:                                                     return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR:                                                            return "VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR";
+               case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR:                                                                       return "VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR:                          return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR:                                      return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR";
+               case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR:                                                                                     return "VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR";
+               case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR:                                      return "VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE:                                                                       return "VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE";
+               case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR:                                         return "VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR:                                         return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR:                                                           return "VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR:                                                            return "VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR:                                                      return "VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR:                                                      return "VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR:                                                         return "VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR:                                                                        return "VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR";
+               case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR:                                                                           return "VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR:                           return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR";
+               case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR:                     return "VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR:                                                        return "VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR:       return "VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR:                                                      return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR";
+               case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR:                                                                      return "VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR";
+               case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR:                                                                            return "VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR";
+               case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR:                           return "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR";
+               case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR:                                                       return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR";
+               case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR:                                                      return "VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR:                                           return "VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR";
+               case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR:                                            return "VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR";
+               case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR:                                                       return "VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR";
+               case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR:                                     return "VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR";
+               case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR:                                                                       return "VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR";
+               case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR:                                          return "VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR";
+               case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR:                                                                     return "VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR";
+               case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR:                                                                      return "VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR";
+               default:                                                                                                                                                        return DE_NULL;
        }
 }
 
@@ -394,14 +445,6 @@ const char* getFormatName (VkFormat value)
                case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:           return "VK_FORMAT_ASTC_12x10_SRGB_BLOCK";
                case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:          return "VK_FORMAT_ASTC_12x12_UNORM_BLOCK";
                case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:           return "VK_FORMAT_ASTC_12x12_SRGB_BLOCK";
-               case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG:     return "VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG";
-               case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG:     return "VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG";
-               case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG:     return "VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG";
-               case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG:     return "VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG";
-               case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG:      return "VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG";
-               case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG:      return "VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG";
-               case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG:      return "VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG";
-               case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG:      return "VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG";
                default:                                                                        return DE_NULL;
        }
 }
@@ -465,17 +508,20 @@ const char* getImageLayoutName (VkImageLayout value)
 {
        switch (value)
        {
-               case VK_IMAGE_LAYOUT_UNDEFINED:                                                 return "VK_IMAGE_LAYOUT_UNDEFINED";
-               case VK_IMAGE_LAYOUT_GENERAL:                                                   return "VK_IMAGE_LAYOUT_GENERAL";
-               case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:                  return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
-               case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:  return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
-               case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:   return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
-               case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:                  return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
-               case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:                              return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
-               case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:                              return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
-               case VK_IMAGE_LAYOUT_PREINITIALIZED:                                    return "VK_IMAGE_LAYOUT_PREINITIALIZED";
-               case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:                                   return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
-               default:                                                                                                return DE_NULL;
+               case VK_IMAGE_LAYOUT_UNDEFINED:                                                                                 return "VK_IMAGE_LAYOUT_UNDEFINED";
+               case VK_IMAGE_LAYOUT_GENERAL:                                                                                   return "VK_IMAGE_LAYOUT_GENERAL";
+               case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:                                                  return "VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL";
+               case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:                                  return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL";
+               case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL:                                   return "VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL";
+               case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:                                                  return "VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL";
+               case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:                                                              return "VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL";
+               case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:                                                              return "VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL";
+               case VK_IMAGE_LAYOUT_PREINITIALIZED:                                                                    return "VK_IMAGE_LAYOUT_PREINITIALIZED";
+               case VK_IMAGE_LAYOUT_PRESENT_SRC_KHR:                                                                   return "VK_IMAGE_LAYOUT_PRESENT_SRC_KHR";
+               case VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR:                                                                return "VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR";
+               case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR:    return "VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR";
+               case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR:    return "VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR";
+               default:                                                                                                                                return DE_NULL;
        }
 }
 
@@ -676,10 +722,9 @@ const char* getFilterName (VkFilter value)
 {
        switch (value)
        {
-               case VK_FILTER_NEAREST:         return "VK_FILTER_NEAREST";
-               case VK_FILTER_LINEAR:          return "VK_FILTER_LINEAR";
-               case VK_FILTER_CUBIC_IMG:       return "VK_FILTER_CUBIC_IMG";
-               default:                                        return DE_NULL;
+               case VK_FILTER_NEAREST: return "VK_FILTER_NEAREST";
+               case VK_FILTER_LINEAR:  return "VK_FILTER_LINEAR";
+               default:                                return DE_NULL;
        }
 }
 
@@ -800,119 +845,161 @@ const char* getSubpassContentsName (VkSubpassContents value)
        }
 }
 
-const char* getColorSpaceKHRName (VkColorSpaceKHR value)
+const char* getObjectTypeName (VkObjectType value)
 {
        switch (value)
        {
-               case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: return "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR";
-               default:                                                                return DE_NULL;
+               case VK_OBJECT_TYPE_UNKNOWN:                                            return "VK_OBJECT_TYPE_UNKNOWN";
+               case VK_OBJECT_TYPE_INSTANCE:                                           return "VK_OBJECT_TYPE_INSTANCE";
+               case VK_OBJECT_TYPE_PHYSICAL_DEVICE:                            return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
+               case VK_OBJECT_TYPE_DEVICE:                                                     return "VK_OBJECT_TYPE_DEVICE";
+               case VK_OBJECT_TYPE_QUEUE:                                                      return "VK_OBJECT_TYPE_QUEUE";
+               case VK_OBJECT_TYPE_SEMAPHORE:                                          return "VK_OBJECT_TYPE_SEMAPHORE";
+               case VK_OBJECT_TYPE_COMMAND_BUFFER:                                     return "VK_OBJECT_TYPE_COMMAND_BUFFER";
+               case VK_OBJECT_TYPE_FENCE:                                                      return "VK_OBJECT_TYPE_FENCE";
+               case VK_OBJECT_TYPE_DEVICE_MEMORY:                                      return "VK_OBJECT_TYPE_DEVICE_MEMORY";
+               case VK_OBJECT_TYPE_BUFFER:                                                     return "VK_OBJECT_TYPE_BUFFER";
+               case VK_OBJECT_TYPE_IMAGE:                                                      return "VK_OBJECT_TYPE_IMAGE";
+               case VK_OBJECT_TYPE_EVENT:                                                      return "VK_OBJECT_TYPE_EVENT";
+               case VK_OBJECT_TYPE_QUERY_POOL:                                         return "VK_OBJECT_TYPE_QUERY_POOL";
+               case VK_OBJECT_TYPE_BUFFER_VIEW:                                        return "VK_OBJECT_TYPE_BUFFER_VIEW";
+               case VK_OBJECT_TYPE_IMAGE_VIEW:                                         return "VK_OBJECT_TYPE_IMAGE_VIEW";
+               case VK_OBJECT_TYPE_SHADER_MODULE:                                      return "VK_OBJECT_TYPE_SHADER_MODULE";
+               case VK_OBJECT_TYPE_PIPELINE_CACHE:                                     return "VK_OBJECT_TYPE_PIPELINE_CACHE";
+               case VK_OBJECT_TYPE_PIPELINE_LAYOUT:                            return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
+               case VK_OBJECT_TYPE_RENDER_PASS:                                        return "VK_OBJECT_TYPE_RENDER_PASS";
+               case VK_OBJECT_TYPE_PIPELINE:                                           return "VK_OBJECT_TYPE_PIPELINE";
+               case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:                      return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
+               case VK_OBJECT_TYPE_SAMPLER:                                            return "VK_OBJECT_TYPE_SAMPLER";
+               case VK_OBJECT_TYPE_DESCRIPTOR_POOL:                            return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
+               case VK_OBJECT_TYPE_DESCRIPTOR_SET:                                     return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
+               case VK_OBJECT_TYPE_FRAMEBUFFER:                                        return "VK_OBJECT_TYPE_FRAMEBUFFER";
+               case VK_OBJECT_TYPE_COMMAND_POOL:                                       return "VK_OBJECT_TYPE_COMMAND_POOL";
+               case VK_OBJECT_TYPE_SURFACE_KHR:                                        return "VK_OBJECT_TYPE_SURFACE_KHR";
+               case VK_OBJECT_TYPE_SWAPCHAIN_KHR:                                      return "VK_OBJECT_TYPE_SWAPCHAIN_KHR";
+               case VK_OBJECT_TYPE_DISPLAY_KHR:                                        return "VK_OBJECT_TYPE_DISPLAY_KHR";
+               case VK_OBJECT_TYPE_DISPLAY_MODE_KHR:                           return "VK_OBJECT_TYPE_DISPLAY_MODE_KHR";
+               case VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT:          return "VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT";
+               case VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR:     return "VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR";
+               case VK_OBJECT_TYPE_OBJECT_TABLE_NVX:                           return "VK_OBJECT_TYPE_OBJECT_TABLE_NVX";
+               case VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX:       return "VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX";
+               default:                                                                                        return DE_NULL;
        }
 }
 
-const char* getPresentModeKHRName (VkPresentModeKHR value)
+const char* getColorSpaceKHRName (VkColorSpaceKHR value)
 {
        switch (value)
        {
-               case VK_PRESENT_MODE_IMMEDIATE_KHR:             return "VK_PRESENT_MODE_IMMEDIATE_KHR";
-               case VK_PRESENT_MODE_MAILBOX_KHR:               return "VK_PRESENT_MODE_MAILBOX_KHR";
-               case VK_PRESENT_MODE_FIFO_KHR:                  return "VK_PRESENT_MODE_FIFO_KHR";
-               case VK_PRESENT_MODE_FIFO_RELAXED_KHR:  return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
-               default:                                                                return DE_NULL;
+               case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR:                 return "VK_COLOR_SPACE_SRGB_NONLINEAR_KHR";
+               case VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT:   return "VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT";
+               case VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT:   return "VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT";
+               case VK_COLOR_SPACE_DCI_P3_LINEAR_EXT:                  return "VK_COLOR_SPACE_DCI_P3_LINEAR_EXT";
+               case VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT:               return "VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT";
+               case VK_COLOR_SPACE_BT709_LINEAR_EXT:                   return "VK_COLOR_SPACE_BT709_LINEAR_EXT";
+               case VK_COLOR_SPACE_BT709_NONLINEAR_EXT:                return "VK_COLOR_SPACE_BT709_NONLINEAR_EXT";
+               case VK_COLOR_SPACE_BT2020_LINEAR_EXT:                  return "VK_COLOR_SPACE_BT2020_LINEAR_EXT";
+               case VK_COLOR_SPACE_HDR10_ST2084_EXT:                   return "VK_COLOR_SPACE_HDR10_ST2084_EXT";
+               case VK_COLOR_SPACE_DOLBYVISION_EXT:                    return "VK_COLOR_SPACE_DOLBYVISION_EXT";
+               case VK_COLOR_SPACE_HDR10_HLG_EXT:                              return "VK_COLOR_SPACE_HDR10_HLG_EXT";
+               case VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT:                return "VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT";
+               case VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT:             return "VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT";
+               case VK_COLOR_SPACE_PASS_THROUGH_EXT:                   return "VK_COLOR_SPACE_PASS_THROUGH_EXT";
+               default:                                                                                return DE_NULL;
        }
 }
 
-const char* getDebugReportObjectTypeEXTName (VkDebugReportObjectTypeEXT value)
+const char* getPresentModeKHRName (VkPresentModeKHR value)
 {
        switch (value)
        {
-               case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:                           return "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:                          return "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:           return "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:                            return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:                                     return "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:                         return "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:            return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:                                     return "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:                     return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:                            return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:                                     return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:                                     return "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:                        return "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:                       return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:                        return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:                     return "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:            return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:           return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:                       return "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:                          return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:     return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:                           return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:           return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:            return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:                       return "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:                      return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:                       return "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:                     return "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT";
-               case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT:                      return "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT";
-               default:                                                                                                        return DE_NULL;
+               case VK_PRESENT_MODE_IMMEDIATE_KHR:                                     return "VK_PRESENT_MODE_IMMEDIATE_KHR";
+               case VK_PRESENT_MODE_MAILBOX_KHR:                                       return "VK_PRESENT_MODE_MAILBOX_KHR";
+               case VK_PRESENT_MODE_FIFO_KHR:                                          return "VK_PRESENT_MODE_FIFO_KHR";
+               case VK_PRESENT_MODE_FIFO_RELAXED_KHR:                          return "VK_PRESENT_MODE_FIFO_RELAXED_KHR";
+               case VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR:         return "VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR";
+               case VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR:     return "VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR";
+               default:                                                                                        return DE_NULL;
        }
 }
 
-const char* getDebugReportErrorEXTName (VkDebugReportErrorEXT value)
+const char* getDescriptorUpdateTemplateTypeKHRName (VkDescriptorUpdateTemplateTypeKHR value)
 {
        switch (value)
        {
-               case VK_DEBUG_REPORT_ERROR_NONE_EXT:                    return "VK_DEBUG_REPORT_ERROR_NONE_EXT";
-               case VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT:    return "VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT";
-               default:                                                                                return DE_NULL;
+               case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR:             return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR";
+               case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR:   return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR";
+               default:                                                                                                                return DE_NULL;
        }
 }
 
-const char* getRasterizationOrderAMDName (VkRasterizationOrderAMD value)
+const char* getPointClippingBehaviorKHRName (VkPointClippingBehaviorKHR value)
 {
        switch (value)
        {
-               case VK_RASTERIZATION_ORDER_STRICT_AMD:         return "VK_RASTERIZATION_ORDER_STRICT_AMD";
-               case VK_RASTERIZATION_ORDER_RELAXED_AMD:        return "VK_RASTERIZATION_ORDER_RELAXED_AMD";
-               default:                                                                        return DE_NULL;
+               case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR:            return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR";
+               case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR:      return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR";
+               default:                                                                                                        return DE_NULL;
        }
 }
 
-const char* getValidationCheckEXTName (VkValidationCheckEXT value)
+const char* getTessellationDomainOriginKHRName (VkTessellationDomainOriginKHR value)
 {
        switch (value)
        {
-               case VK_VALIDATION_CHECK_ALL_EXT:       return "VK_VALIDATION_CHECK_ALL_EXT";
-               default:                                                        return DE_NULL;
+               case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR:      return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR";
+               case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR:      return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR";
+               default:                                                                                        return DE_NULL;
        }
 }
 
-const char* getIndirectCommandsTokenTypeNVXName (VkIndirectCommandsTokenTypeNVX value)
+const char* getDebugReportObjectTypeEXTName (VkDebugReportObjectTypeEXT value)
 {
        switch (value)
        {
-               case VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX:           return "VK_INDIRECT_COMMANDS_TOKEN_PIPELINE_NVX";
-               case VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX:     return "VK_INDIRECT_COMMANDS_TOKEN_DESCRIPTOR_SET_NVX";
-               case VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX:       return "VK_INDIRECT_COMMANDS_TOKEN_INDEX_BUFFER_NVX";
-               case VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX:      return "VK_INDIRECT_COMMANDS_TOKEN_VERTEX_BUFFER_NVX";
-               case VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX:      return "VK_INDIRECT_COMMANDS_TOKEN_PUSH_CONSTANT_NVX";
-               case VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX:       return "VK_INDIRECT_COMMANDS_TOKEN_DRAW_INDEXED_NVX";
-               case VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX:                       return "VK_INDIRECT_COMMANDS_TOKEN_DRAW_NVX";
-               case VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX:           return "VK_INDIRECT_COMMANDS_TOKEN_DISPATCH_NVX";
-               default:                                                                                        return DE_NULL;
+               case VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT:                                                   return "VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT:                                                  return "VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT:                                   return "VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT:                                                    return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT:                                                             return "VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT:                                                 return "VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT:                                    return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT:                                                             return "VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT:                                             return "VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT:                                                    return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT:                                                             return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT:                                                             return "VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT:                                                return "VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT:                                               return "VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT:                                                return "VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT:                                             return "VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT:                                    return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT:                                   return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT:                                               return "VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT:                                                  return "VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT:                             return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT:                                                   return "VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT:                                   return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT:                                    return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT:                                               return "VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT:                                              return "VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT:                                               return "VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT:                                             return "VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT:                                              return "VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT:                                               return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT:                                  return "VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT";
+               case VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT:    return "VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT";
+               default:                                                                                                                                return DE_NULL;
        }
 }
 
-const char* getObjectEntryTypeNVXName (VkObjectEntryTypeNVX value)
+const char* getDebugReportErrorEXTName (VkDebugReportErrorEXT value)
 {
        switch (value)
        {
-               case VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX:        return "VK_OBJECT_ENTRY_DESCRIPTOR_SET_NVX";
-               case VK_OBJECT_ENTRY_PIPELINE_NVX:                      return "VK_OBJECT_ENTRY_PIPELINE_NVX";
-               case VK_OBJECT_ENTRY_INDEX_BUFFER_NVX:          return "VK_OBJECT_ENTRY_INDEX_BUFFER_NVX";
-               case VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX:         return "VK_OBJECT_ENTRY_VERTEX_BUFFER_NVX";
-               case VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX:         return "VK_OBJECT_ENTRY_PUSH_CONSTANT_NVX";
-               default:                                                                        return DE_NULL;
+               case VK_DEBUG_REPORT_ERROR_NONE_EXT:                    return "VK_DEBUG_REPORT_ERROR_NONE_EXT";
+               case VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT:    return "VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT";
+               default:                                                                                return DE_NULL;
        }
 }
 
@@ -920,20 +1007,21 @@ tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,                                       "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,                                       "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,                        "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,                        "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,                        "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT,         "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,                                       "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,                            "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,                      "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,            "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_SRC_BIT,                                            "VK_FORMAT_FEATURE_BLIT_SRC_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_DST_BIT,                                            "VK_FORMAT_FEATURE_BLIT_DST_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT,         "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"),
-               tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,      "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT,                               "VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT,                               "VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT,                "VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT,                "VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT,                "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT, "VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT,                               "VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT,                    "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT,              "VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT,    "VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_SRC_BIT,                                    "VK_FORMAT_FEATURE_BLIT_SRC_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_BLIT_DST_BIT,                                    "VK_FORMAT_FEATURE_BLIT_DST_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT, "VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR,                    "VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR"),
+               tcu::Format::BitDesc(VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR,                    "VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
@@ -958,11 +1046,16 @@ tcu::Format::Bitfield<32> getImageCreateFlagsStr (VkImageCreateFlags value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_BINDING_BIT,        "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"),
-               tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,      "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"),
-               tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,        "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"),
-               tcu::Format::BitDesc(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,        "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
-               tcu::Format::BitDesc(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,       "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_BINDING_BIT,                                        "VK_IMAGE_CREATE_SPARSE_BINDING_BIT"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT,                                      "VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,                                        "VK_IMAGE_CREATE_SPARSE_ALIASED_BIT"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,                                        "VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,                                       "VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_BIND_SFR_BIT_KHX,                                          "VK_IMAGE_CREATE_BIND_SFR_BIT_KHX"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR,                       "VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR,       "VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR,                            "VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_IMAGE_CREATE_ALIAS_BIT_KHR,                                                     "VK_IMAGE_CREATE_ALIAS_BIT_KHR"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
@@ -1011,7 +1104,8 @@ tcu::Format::Bitfield<32> getMemoryHeapFlagsStr (VkMemoryHeapFlags value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,   "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"),
+               tcu::Format::BitDesc(VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,           "VK_MEMORY_HEAP_DEVICE_LOCAL_BIT"),
+               tcu::Format::BitDesc(VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX,     "VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHX"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
@@ -1037,7 +1131,6 @@ tcu::Format::Bitfield<32> getPipelineStageFlagsStr (VkPipelineStageFlags value)
                tcu::Format::BitDesc(VK_PIPELINE_STAGE_HOST_BIT,                                                        "VK_PIPELINE_STAGE_HOST_BIT"),
                tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,                                        "VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT"),
                tcu::Format::BitDesc(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,                                        "VK_PIPELINE_STAGE_ALL_COMMANDS_BIT"),
-               tcu::Format::BitDesc(VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX,                         "VK_PIPELINE_STAGE_COMMAND_PROCESS_BIT_NVX"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
@@ -1146,9 +1239,11 @@ tcu::Format::Bitfield<32> getPipelineCreateFlagsStr (VkPipelineCreateFlags value
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,       "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
-               tcu::Format::BitDesc(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,          "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
-               tcu::Format::BitDesc(VK_PIPELINE_CREATE_DERIVATIVE_BIT,                         "VK_PIPELINE_CREATE_DERIVATIVE_BIT"),
+               tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT,                               "VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT"),
+               tcu::Format::BitDesc(VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT,                                  "VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT"),
+               tcu::Format::BitDesc(VK_PIPELINE_CREATE_DERIVATIVE_BIT,                                                 "VK_PIPELINE_CREATE_DERIVATIVE_BIT"),
+               tcu::Format::BitDesc(VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX,   "VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHX"),
+               tcu::Format::BitDesc(VK_PIPELINE_CREATE_DISPATCH_BASE_KHX,                                              "VK_PIPELINE_CREATE_DISPATCH_BASE_KHX"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
@@ -1193,6 +1288,15 @@ tcu::Format::Bitfield<32> getColorComponentFlagsStr (VkColorComponentFlags value
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
+tcu::Format::Bitfield<32> getDescriptorSetLayoutCreateFlagsStr (VkDescriptorSetLayoutCreateFlags value)
+{
+       static const tcu::Format::BitDesc s_desc[] =
+       {
+               tcu::Format::BitDesc(VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR,   "VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR"),
+       };
+       return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
 tcu::Format::Bitfield<32> getDescriptorPoolCreateFlagsStr (VkDescriptorPoolCreateFlags value)
 {
        static const tcu::Format::BitDesc s_desc[] =
@@ -1211,6 +1315,11 @@ tcu::Format::Bitfield<32> getAttachmentDescriptionFlagsStr (VkAttachmentDescript
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
+tcu::Format::Bitfield<32> getSubpassDescriptionFlagsStr (VkSubpassDescriptionFlags value)
+{
+       return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
 tcu::Format::Bitfield<32> getAccessFlagsStr (VkAccessFlags value)
 {
        static const tcu::Format::BitDesc s_desc[] =
@@ -1240,7 +1349,9 @@ tcu::Format::Bitfield<32> getDependencyFlagsStr (VkDependencyFlags value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_DEPENDENCY_BY_REGION_BIT,       "VK_DEPENDENCY_BY_REGION_BIT"),
+               tcu::Format::BitDesc(VK_DEPENDENCY_BY_REGION_BIT,                       "VK_DEPENDENCY_BY_REGION_BIT"),
+               tcu::Format::BitDesc(VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX,          "VK_DEPENDENCY_VIEW_LOCAL_BIT_KHX"),
+               tcu::Format::BitDesc(VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX,        "VK_DEPENDENCY_DEVICE_GROUP_BIT_KHX"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
@@ -1333,6 +1444,15 @@ tcu::Format::Bitfield<32> getCompositeAlphaFlagsKHRStr (VkCompositeAlphaFlagsKHR
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
+tcu::Format::Bitfield<32> getSwapchainCreateFlagsKHRStr (VkSwapchainCreateFlagsKHR value)
+{
+       static const tcu::Format::BitDesc s_desc[] =
+       {
+               tcu::Format::BitDesc(VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX,      "VK_SWAPCHAIN_CREATE_BIND_SFR_BIT_KHX"),
+       };
+       return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
 tcu::Format::Bitfield<32> getDisplayPlaneAlphaFlagsKHRStr (VkDisplayPlaneAlphaFlagsKHR value)
 {
        static const tcu::Format::BitDesc s_desc[] =
@@ -1345,6 +1465,37 @@ tcu::Format::Bitfield<32> getDisplayPlaneAlphaFlagsKHRStr (VkDisplayPlaneAlphaFl
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
+tcu::Format::Bitfield<32> getExternalFenceHandleTypeFlagsKHRStr (VkExternalFenceHandleTypeFlagsKHR value)
+{
+       static const tcu::Format::BitDesc s_desc[] =
+       {
+               tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,                   "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,                "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,    "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR,                             "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR"),
+       };
+       return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getExternalFenceFeatureFlagsKHRStr (VkExternalFenceFeatureFlagsKHR value)
+{
+       static const tcu::Format::BitDesc s_desc[] =
+       {
+               tcu::Format::BitDesc(VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR,      "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR,      "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR"),
+       };
+       return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getFenceImportFlagsKHRStr (VkFenceImportFlagsKHR value)
+{
+       static const tcu::Format::BitDesc s_desc[] =
+       {
+               tcu::Format::BitDesc(VK_FENCE_IMPORT_TEMPORARY_BIT_KHR, "VK_FENCE_IMPORT_TEMPORARY_BIT_KHR"),
+       };
+       return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
 tcu::Format::Bitfield<32> getDebugReportFlagsEXTStr (VkDebugReportFlagsEXT value)
 {
        static const tcu::Format::BitDesc s_desc[] =
@@ -1358,47 +1509,60 @@ tcu::Format::Bitfield<32> getDebugReportFlagsEXTStr (VkDebugReportFlagsEXT value
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
-tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsNVStr (VkExternalMemoryHandleTypeFlagsNV value)
+tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsKHRStr (VkExternalMemoryHandleTypeFlagsKHR value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV,                "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV"),
-               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV,    "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV"),
-               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV,                 "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV"),
-               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV,             "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,                  "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,               "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,   "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR,              "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR,  "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR,                 "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR,             "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
-tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsNVStr (VkExternalMemoryFeatureFlagsNV value)
+tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsKHRStr (VkExternalMemoryFeatureFlagsKHR value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV,  "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV"),
-               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV,              "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV"),
-               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV,              "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR, "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR,             "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR,             "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
-tcu::Format::Bitfield<32> getIndirectCommandsLayoutUsageFlagsNVXStr (VkIndirectCommandsLayoutUsageFlagsNVX value)
+tcu::Format::Bitfield<32> getExternalSemaphoreHandleTypeFlagsKHRStr (VkExternalSemaphoreHandleTypeFlagsKHR value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX,     "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NVX"),
-               tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX,        "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_SPARSE_SEQUENCES_BIT_NVX"),
-               tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX,        "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EMPTY_EXECUTIONS_BIT_NVX"),
-               tcu::Format::BitDesc(VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX,       "VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NVX"),
+               tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,                       "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,            "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,        "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR,                     "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR,                         "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
 
-tcu::Format::Bitfield<32> getObjectEntryUsageFlagsNVXStr (VkObjectEntryUsageFlagsNVX value)
+tcu::Format::Bitfield<32> getExternalSemaphoreFeatureFlagsKHRStr (VkExternalSemaphoreFeatureFlagsKHR value)
 {
        static const tcu::Format::BitDesc s_desc[] =
        {
-               tcu::Format::BitDesc(VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX,    "VK_OBJECT_ENTRY_USAGE_GRAPHICS_BIT_NVX"),
-               tcu::Format::BitDesc(VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX,             "VK_OBJECT_ENTRY_USAGE_COMPUTE_BIT_NVX"),
+               tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR,  "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR"),
+               tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR,  "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR"),
+       };
+       return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
+}
+
+tcu::Format::Bitfield<32> getSemaphoreImportFlagsKHRStr (VkSemaphoreImportFlagsKHR value)
+{
+       static const tcu::Format::BitDesc s_desc[] =
+       {
+               tcu::Format::BitDesc(VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR,     "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR"),
        };
        return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
 }
@@ -1518,11 +1682,6 @@ tcu::Format::Bitfield<32> getSamplerCreateFlagsStr (VkSamplerCreateFlags value)
        return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
 }
 
-tcu::Format::Bitfield<32> getDescriptorSetLayoutCreateFlagsStr (VkDescriptorSetLayoutCreateFlags value)
-{
-       return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
-}
-
 tcu::Format::Bitfield<32> getDescriptorPoolResetFlagsStr (VkDescriptorPoolResetFlags value)
 {
        return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
@@ -1538,16 +1697,6 @@ tcu::Format::Bitfield<32> getRenderPassCreateFlagsStr (VkRenderPassCreateFlags v
        return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
 }
 
-tcu::Format::Bitfield<32> getSubpassDescriptionFlagsStr (VkSubpassDescriptionFlags value)
-{
-       return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
-}
-
-tcu::Format::Bitfield<32> getSwapchainCreateFlagsKHRStr (VkSwapchainCreateFlagsKHR value)
-{
-       return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
-}
-
 tcu::Format::Bitfield<32> getDisplayModeCreateFlagsKHRStr (VkDisplayModeCreateFlagsKHR value)
 {
        return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
@@ -1588,6 +1737,16 @@ tcu::Format::Bitfield<32> getWin32SurfaceCreateFlagsKHRStr (VkWin32SurfaceCreate
        return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
 }
 
+tcu::Format::Bitfield<32> getCommandPoolTrimFlagsKHRStr (VkCommandPoolTrimFlagsKHR value)
+{
+       return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
+tcu::Format::Bitfield<32> getDescriptorUpdateTemplateCreateFlagsKHRStr (VkDescriptorUpdateTemplateCreateFlagsKHR value)
+{
+       return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
+}
+
 std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value)
 {
        s << "VkApplicationInfo = {\n";
@@ -3325,340 +3484,870 @@ std::ostream& operator<< (std::ostream& s, const VkWin32SurfaceCreateInfoKHR& va
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceFeatures2KHR& value)
 {
-       s << "VkDebugReportCallbackCreateInfoEXT = {\n";
+       s << "VkPhysicalDeviceFeatures2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tflags = " << getDebugReportFlagsEXTStr(value.flags) << '\n';
-       s << "\tpfnCallback = " << value.pfnCallback << '\n';
-       s << "\tpUserData = " << value.pUserData << '\n';
+       s << "\tfeatures = " << value.features << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkPipelineRasterizationStateRasterizationOrderAMD& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceProperties2KHR& value)
 {
-       s << "VkPipelineRasterizationStateRasterizationOrderAMD = {\n";
+       s << "VkPhysicalDeviceProperties2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\trasterizationOrder = " << value.rasterizationOrder << '\n';
+       s << "\tproperties = " << value.properties << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDebugMarkerObjectNameInfoEXT& value)
+std::ostream& operator<< (std::ostream& s, const VkFormatProperties2KHR& value)
 {
-       s << "VkDebugMarkerObjectNameInfoEXT = {\n";
+       s << "VkFormatProperties2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tobjectType = " << value.objectType << '\n';
-       s << "\tobject = " << value.object << '\n';
-       s << "\tpObjectName = " << getCharPtrStr(value.pObjectName) << '\n';
+       s << "\tformatProperties = " << value.formatProperties << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDebugMarkerObjectTagInfoEXT& value)
+std::ostream& operator<< (std::ostream& s, const VkImageFormatProperties2KHR& value)
 {
-       s << "VkDebugMarkerObjectTagInfoEXT = {\n";
+       s << "VkImageFormatProperties2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tobjectType = " << value.objectType << '\n';
-       s << "\tobject = " << value.object << '\n';
-       s << "\ttagName = " << value.tagName << '\n';
-       s << "\ttagSize = " << value.tagSize << '\n';
-       s << "\tpTag = " << value.pTag << '\n';
+       s << "\timageFormatProperties = " << value.imageFormatProperties << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDebugMarkerMarkerInfoEXT& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceImageFormatInfo2KHR& value)
 {
-       s << "VkDebugMarkerMarkerInfoEXT = {\n";
+       s << "VkPhysicalDeviceImageFormatInfo2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tpMarkerName = " << getCharPtrStr(value.pMarkerName) << '\n';
-       s << "\tcolor = " << '\n' << tcu::formatArray(DE_ARRAY_BEGIN(value.color), DE_ARRAY_END(value.color)) << '\n';
+       s << "\tformat = " << value.format << '\n';
+       s << "\ttype = " << value.type << '\n';
+       s << "\ttiling = " << value.tiling << '\n';
+       s << "\tusage = " << getImageUsageFlagsStr(value.usage) << '\n';
+       s << "\tflags = " << getImageCreateFlagsStr(value.flags) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDedicatedAllocationImageCreateInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkQueueFamilyProperties2KHR& value)
 {
-       s << "VkDedicatedAllocationImageCreateInfoNV = {\n";
+       s << "VkQueueFamilyProperties2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tdedicatedAllocation = " << value.dedicatedAllocation << '\n';
+       s << "\tqueueFamilyProperties = " << value.queueFamilyProperties << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDedicatedAllocationBufferCreateInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMemoryProperties2KHR& value)
 {
-       s << "VkDedicatedAllocationBufferCreateInfoNV = {\n";
+       s << "VkPhysicalDeviceMemoryProperties2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tdedicatedAllocation = " << value.dedicatedAllocation << '\n';
+       s << "\tmemoryProperties = " << value.memoryProperties << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDedicatedAllocationMemoryAllocateInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkSparseImageFormatProperties2KHR& value)
 {
-       s << "VkDedicatedAllocationMemoryAllocateInfoNV = {\n";
+       s << "VkSparseImageFormatProperties2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\timage = " << value.image << '\n';
-       s << "\tbuffer = " << value.buffer << '\n';
+       s << "\tproperties = " << value.properties << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkExternalImageFormatPropertiesNV& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSparseImageFormatInfo2KHR& value)
 {
-       s << "VkExternalImageFormatPropertiesNV = {\n";
-       s << "\timageFormatProperties = " << value.imageFormatProperties << '\n';
-       s << "\texternalMemoryFeatures = " << getExternalMemoryFeatureFlagsNVStr(value.externalMemoryFeatures) << '\n';
-       s << "\texportFromImportedHandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.exportFromImportedHandleTypes) << '\n';
-       s << "\tcompatibleHandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.compatibleHandleTypes) << '\n';
+       s << "VkPhysicalDeviceSparseImageFormatInfo2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tformat = " << value.format << '\n';
+       s << "\ttype = " << value.type << '\n';
+       s << "\tsamples = " << value.samples << '\n';
+       s << "\tusage = " << getImageUsageFlagsStr(value.usage) << '\n';
+       s << "\ttiling = " << value.tiling << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePushDescriptorPropertiesKHR& value)
+{
+       s << "VkPhysicalDevicePushDescriptorPropertiesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmaxPushDescriptors = " << value.maxPushDescriptors << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkExternalMemoryImageCreateInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevice16BitStorageFeaturesKHR& value)
 {
-       s << "VkExternalMemoryImageCreateInfoNV = {\n";
+       s << "VkPhysicalDevice16BitStorageFeaturesKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.handleTypes) << '\n';
+       s << "\tstorageBuffer16BitAccess = " << value.storageBuffer16BitAccess << '\n';
+       s << "\tuniformAndStorageBuffer16BitAccess = " << value.uniformAndStorageBuffer16BitAccess << '\n';
+       s << "\tstoragePushConstant16 = " << value.storagePushConstant16 << '\n';
+       s << "\tstorageInputOutput16 = " << value.storageInputOutput16 << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkRectLayerKHR& value)
+{
+       s << "VkRectLayerKHR = {\n";
+       s << "\toffset = " << value.offset << '\n';
+       s << "\textent = " << value.extent << '\n';
+       s << "\tlayer = " << value.layer << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPresentRegionKHR& value)
+{
+       s << "VkPresentRegionKHR = {\n";
+       s << "\trectangleCount = " << value.rectangleCount << '\n';
+       s << "\tpRectangles = " << value.pRectangles << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkExportMemoryAllocateInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkPresentRegionsKHR& value)
 {
-       s << "VkExportMemoryAllocateInfoNV = {\n";
+       s << "VkPresentRegionsKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsNVStr(value.handleTypes) << '\n';
+       s << "\tswapchainCount = " << value.swapchainCount << '\n';
+       s << "\tpRegions = " << value.pRegions << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkImportMemoryWin32HandleInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkDescriptorUpdateTemplateEntryKHR& value)
 {
-       s << "VkImportMemoryWin32HandleInfoNV = {\n";
+       s << "VkDescriptorUpdateTemplateEntryKHR = {\n";
+       s << "\tdstBinding = " << value.dstBinding << '\n';
+       s << "\tdstArrayElement = " << value.dstArrayElement << '\n';
+       s << "\tdescriptorCount = " << value.descriptorCount << '\n';
+       s << "\tdescriptorType = " << value.descriptorType << '\n';
+       s << "\toffset = " << value.offset << '\n';
+       s << "\tstride = " << value.stride << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkDescriptorUpdateTemplateCreateInfoKHR& value)
+{
+       s << "VkDescriptorUpdateTemplateCreateInfoKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\thandleType = " << getExternalMemoryHandleTypeFlagsNVStr(value.handleType) << '\n';
-       s << "\thandle = " << value.handle << '\n';
+       s << "\tflags = " << getDescriptorUpdateTemplateCreateFlagsKHRStr(value.flags) << '\n';
+       s << "\tdescriptorUpdateEntryCount = " << value.descriptorUpdateEntryCount << '\n';
+       s << "\tpDescriptorUpdateEntries = " << value.pDescriptorUpdateEntries << '\n';
+       s << "\ttemplateType = " << value.templateType << '\n';
+       s << "\tdescriptorSetLayout = " << value.descriptorSetLayout << '\n';
+       s << "\tpipelineBindPoint = " << value.pipelineBindPoint << '\n';
+       s << "\tpipelineLayout = " << value.pipelineLayout << '\n';
+       s << "\tset = " << value.set << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkExportMemoryWin32HandleInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkSharedPresentSurfaceCapabilitiesKHR& value)
 {
-       s << "VkExportMemoryWin32HandleInfoNV = {\n";
+       s << "VkSharedPresentSurfaceCapabilitiesKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tpAttributes = " << value.pAttributes << '\n';
-       s << "\tdwAccess = " << value.dwAccess << '\n';
+       s << "\tsharedPresentSupportedUsageFlags = " << getImageUsageFlagsStr(value.sharedPresentSupportedUsageFlags) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkWin32KeyedMutexAcquireReleaseInfoNV& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDevicePointClippingPropertiesKHR& value)
 {
-       s << "VkWin32KeyedMutexAcquireReleaseInfoNV = {\n";
+       s << "VkPhysicalDevicePointClippingPropertiesKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tacquireCount = " << value.acquireCount << '\n';
-       s << "\tpAcquireSyncs = " << value.pAcquireSyncs << '\n';
-       s << "\tpAcquireKeys = " << value.pAcquireKeys << '\n';
-       s << "\tpAcquireTimeoutMilliseconds = " << value.pAcquireTimeoutMilliseconds << '\n';
-       s << "\treleaseCount = " << value.releaseCount << '\n';
-       s << "\tpReleaseSyncs = " << value.pReleaseSyncs << '\n';
-       s << "\tpReleaseKeys = " << value.pReleaseKeys << '\n';
+       s << "\tpointClippingBehavior = " << value.pointClippingBehavior << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkInputAttachmentAspectReferenceKHR& value)
+{
+       s << "VkInputAttachmentAspectReferenceKHR = {\n";
+       s << "\tsubpass = " << value.subpass << '\n';
+       s << "\tinputAttachmentIndex = " << value.inputAttachmentIndex << '\n';
+       s << "\taspectMask = " << getImageAspectFlagsStr(value.aspectMask) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkValidationFlagsEXT& value)
+std::ostream& operator<< (std::ostream& s, const VkRenderPassInputAttachmentAspectCreateInfoKHR& value)
 {
-       s << "VkValidationFlagsEXT = {\n";
+       s << "VkRenderPassInputAttachmentAspectCreateInfoKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tdisabledValidationCheckCount = " << value.disabledValidationCheckCount << '\n';
-       s << "\tpDisabledValidationChecks = " << value.pDisabledValidationChecks << '\n';
+       s << "\taspectReferenceCount = " << value.aspectReferenceCount << '\n';
+       s << "\tpAspectReferences = " << value.pAspectReferences << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsFeaturesNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkImageViewUsageCreateInfoKHR& value)
 {
-       s << "VkDeviceGeneratedCommandsFeaturesNVX = {\n";
+       s << "VkImageViewUsageCreateInfoKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tcomputeBindingPointSupport = " << value.computeBindingPointSupport << '\n';
+       s << "\tusage = " << getImageUsageFlagsStr(value.usage) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkDeviceGeneratedCommandsLimitsNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkPipelineTessellationDomainOriginStateCreateInfoKHR& value)
 {
-       s << "VkDeviceGeneratedCommandsLimitsNVX = {\n";
+       s << "VkPipelineTessellationDomainOriginStateCreateInfoKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tmaxIndirectCommandsLayoutTokenCount = " << value.maxIndirectCommandsLayoutTokenCount << '\n';
-       s << "\tmaxObjectEntryCounts = " << value.maxObjectEntryCounts << '\n';
-       s << "\tminSequenceCountBufferOffsetAlignment = " << value.minSequenceCountBufferOffsetAlignment << '\n';
-       s << "\tminSequenceIndexBufferOffsetAlignment = " << value.minSequenceIndexBufferOffsetAlignment << '\n';
-       s << "\tminCommandsTokenBufferOffsetAlignment = " << value.minCommandsTokenBufferOffsetAlignment << '\n';
+       s << "\tdomainOrigin = " << value.domainOrigin << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsTokenNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceSurfaceInfo2KHR& value)
 {
-       s << "VkIndirectCommandsTokenNVX = {\n";
-       s << "\ttokenType = " << value.tokenType << '\n';
-       s << "\tbuffer = " << value.buffer << '\n';
-       s << "\toffset = " << value.offset << '\n';
+       s << "VkPhysicalDeviceSurfaceInfo2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tsurface = " << value.surface << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsLayoutTokenNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkSurfaceCapabilities2KHR& value)
 {
-       s << "VkIndirectCommandsLayoutTokenNVX = {\n";
-       s << "\ttokenType = " << value.tokenType << '\n';
-       s << "\tbindingUnit = " << value.bindingUnit << '\n';
-       s << "\tdynamicCount = " << value.dynamicCount << '\n';
-       s << "\tdivisor = " << value.divisor << '\n';
+       s << "VkSurfaceCapabilities2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tsurfaceCapabilities = " << value.surfaceCapabilities << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkIndirectCommandsLayoutCreateInfoNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkSurfaceFormat2KHR& value)
 {
-       s << "VkIndirectCommandsLayoutCreateInfoNVX = {\n";
+       s << "VkSurfaceFormat2KHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tpipelineBindPoint = " << value.pipelineBindPoint << '\n';
-       s << "\tflags = " << getIndirectCommandsLayoutUsageFlagsNVXStr(value.flags) << '\n';
-       s << "\ttokenCount = " << value.tokenCount << '\n';
-       s << "\tpTokens = " << value.pTokens << '\n';
+       s << "\tsurfaceFormat = " << value.surfaceFormat << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkCmdProcessCommandsInfoNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalFenceInfoKHR& value)
 {
-       s << "VkCmdProcessCommandsInfoNVX = {\n";
+       s << "VkPhysicalDeviceExternalFenceInfoKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tobjectTable = " << value.objectTable << '\n';
-       s << "\tindirectCommandsLayout = " << value.indirectCommandsLayout << '\n';
-       s << "\tindirectCommandsTokenCount = " << value.indirectCommandsTokenCount << '\n';
-       s << "\tpIndirectCommandsTokens = " << value.pIndirectCommandsTokens << '\n';
-       s << "\tmaxSequencesCount = " << value.maxSequencesCount << '\n';
-       s << "\ttargetCommandBuffer = " << value.targetCommandBuffer << '\n';
-       s << "\tsequencesCountBuffer = " << value.sequencesCountBuffer << '\n';
-       s << "\tsequencesCountOffset = " << value.sequencesCountOffset << '\n';
-       s << "\tsequencesIndexBuffer = " << value.sequencesIndexBuffer << '\n';
-       s << "\tsequencesIndexOffset = " << value.sequencesIndexOffset << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkCmdReserveSpaceForCommandsInfoNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkExternalFencePropertiesKHR& value)
 {
-       s << "VkCmdReserveSpaceForCommandsInfoNVX = {\n";
+       s << "VkExternalFencePropertiesKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tobjectTable = " << value.objectTable << '\n';
-       s << "\tindirectCommandsLayout = " << value.indirectCommandsLayout << '\n';
-       s << "\tmaxSequencesCount = " << value.maxSequencesCount << '\n';
+       s << "\texportFromImportedHandleTypes = " << getExternalFenceHandleTypeFlagsKHRStr(value.exportFromImportedHandleTypes) << '\n';
+       s << "\tcompatibleHandleTypes = " << getExternalFenceHandleTypeFlagsKHRStr(value.compatibleHandleTypes) << '\n';
+       s << "\texternalFenceFeatures = " << getExternalFenceFeatureFlagsKHRStr(value.externalFenceFeatures) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkObjectTableCreateInfoNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkExportFenceCreateInfoKHR& value)
 {
-       s << "VkObjectTableCreateInfoNVX = {\n";
+       s << "VkExportFenceCreateInfoKHR = {\n";
        s << "\tsType = " << value.sType << '\n';
        s << "\tpNext = " << value.pNext << '\n';
-       s << "\tobjectCount = " << value.objectCount << '\n';
-       s << "\tpObjectEntryTypes = " << value.pObjectEntryTypes << '\n';
-       s << "\tpObjectEntryCounts = " << value.pObjectEntryCounts << '\n';
-       s << "\tpObjectEntryUsageFlags = " << value.pObjectEntryUsageFlags << '\n';
-       s << "\tmaxUniformBuffersPerDescriptor = " << value.maxUniformBuffersPerDescriptor << '\n';
-       s << "\tmaxStorageBuffersPerDescriptor = " << value.maxStorageBuffersPerDescriptor << '\n';
-       s << "\tmaxStorageImagesPerDescriptor = " << value.maxStorageImagesPerDescriptor << '\n';
-       s << "\tmaxSampledImagesPerDescriptor = " << value.maxSampledImagesPerDescriptor << '\n';
-       s << "\tmaxPipelineLayouts = " << value.maxPipelineLayouts << '\n';
+       s << "\thandleTypes = " << getExternalFenceHandleTypeFlagsKHRStr(value.handleTypes) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkObjectTableEntryNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkImportFenceWin32HandleInfoKHR& value)
 {
-       s << "VkObjectTableEntryNVX = {\n";
-       s << "\ttype = " << value.type << '\n';
-       s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
+       s << "VkImportFenceWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tfence = " << value.fence << '\n';
+       s << "\tflags = " << getFenceImportFlagsKHRStr(value.flags) << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << "\thandle = " << value.handle << '\n';
+       s << "\tname = " << getCharPtrStr(value.name) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkObjectTablePipelineEntryNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkExportFenceWin32HandleInfoKHR& value)
 {
-       s << "VkObjectTablePipelineEntryNVX = {\n";
-       s << "\ttype = " << value.type << '\n';
-       s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
-       s << "\tpipeline = " << value.pipeline << '\n';
+       s << "VkExportFenceWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tpAttributes = " << value.pAttributes << '\n';
+       s << "\tdwAccess = " << value.dwAccess << '\n';
+       s << "\tname = " << getCharPtrStr(value.name) << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkObjectTableDescriptorSetEntryNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkFenceGetWin32HandleInfoKHR& value)
 {
-       s << "VkObjectTableDescriptorSetEntryNVX = {\n";
-       s << "\ttype = " << value.type << '\n';
-       s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
-       s << "\tpipelineLayout = " << value.pipelineLayout << '\n';
-       s << "\tdescriptorSet = " << value.descriptorSet << '\n';
+       s << "VkFenceGetWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tfence = " << value.fence << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkObjectTableVertexBufferEntryNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkImportFenceFdInfoKHR& value)
 {
-       s << "VkObjectTableVertexBufferEntryNVX = {\n";
-       s << "\ttype = " << value.type << '\n';
-       s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
+       s << "VkImportFenceFdInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tfence = " << value.fence << '\n';
+       s << "\tflags = " << getFenceImportFlagsKHRStr(value.flags) << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << "\tfd = " << value.fd << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkFenceGetFdInfoKHR& value)
+{
+       s << "VkFenceGetFdInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tfence = " << value.fence << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryDedicatedRequirementsKHR& value)
+{
+       s << "VkMemoryDedicatedRequirementsKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tprefersDedicatedAllocation = " << value.prefersDedicatedAllocation << '\n';
+       s << "\trequiresDedicatedAllocation = " << value.requiresDedicatedAllocation << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryDedicatedAllocateInfoKHR& value)
+{
+       s << "VkMemoryDedicatedAllocateInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\timage = " << value.image << '\n';
        s << "\tbuffer = " << value.buffer << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkObjectTableIndexBufferEntryNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkBufferMemoryRequirementsInfo2KHR& value)
 {
-       s << "VkObjectTableIndexBufferEntryNVX = {\n";
-       s << "\ttype = " << value.type << '\n';
-       s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
+       s << "VkBufferMemoryRequirementsInfo2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
        s << "\tbuffer = " << value.buffer << '\n';
        s << '}';
        return s;
 }
 
-std::ostream& operator<< (std::ostream& s, const VkObjectTablePushConstantEntryNVX& value)
+std::ostream& operator<< (std::ostream& s, const VkImageMemoryRequirementsInfo2KHR& value)
 {
-       s << "VkObjectTablePushConstantEntryNVX = {\n";
-       s << "\ttype = " << value.type << '\n';
-       s << "\tflags = " << getObjectEntryUsageFlagsNVXStr(value.flags) << '\n';
-       s << "\tpipelineLayout = " << value.pipelineLayout << '\n';
-       s << "\tstageFlags = " << getShaderStageFlagsStr(value.stageFlags) << '\n';
+       s << "VkImageMemoryRequirementsInfo2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\timage = " << value.image << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImageSparseMemoryRequirementsInfo2KHR& value)
+{
+       s << "VkImageSparseMemoryRequirementsInfo2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\timage = " << value.image << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryRequirements2KHR& value)
+{
+       s << "VkMemoryRequirements2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmemoryRequirements = " << value.memoryRequirements << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSparseImageMemoryRequirements2KHR& value)
+{
+       s << "VkSparseImageMemoryRequirements2KHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmemoryRequirements = " << value.memoryRequirements << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImageFormatListCreateInfoKHR& value)
+{
+       s << "VkImageFormatListCreateInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tviewFormatCount = " << value.viewFormatCount << '\n';
+       s << "\tpViewFormats = " << value.pViewFormats << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkDebugReportCallbackCreateInfoEXT& value)
+{
+       s << "VkDebugReportCallbackCreateInfoEXT = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tflags = " << getDebugReportFlagsEXTStr(value.flags) << '\n';
+       s << "\tpfnCallback = " << value.pfnCallback << '\n';
+       s << "\tpUserData = " << value.pUserData << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkRenderPassMultiviewCreateInfoKHX& value)
+{
+       s << "VkRenderPassMultiviewCreateInfoKHX = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tsubpassCount = " << value.subpassCount << '\n';
+       s << "\tpViewMasks = " << value.pViewMasks << '\n';
+       s << "\tdependencyCount = " << value.dependencyCount << '\n';
+       s << "\tpViewOffsets = " << value.pViewOffsets << '\n';
+       s << "\tcorrelationMaskCount = " << value.correlationMaskCount << '\n';
+       s << "\tpCorrelationMasks = " << value.pCorrelationMasks << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMultiviewFeaturesKHX& value)
+{
+       s << "VkPhysicalDeviceMultiviewFeaturesKHX = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmultiview = " << value.multiview << '\n';
+       s << "\tmultiviewGeometryShader = " << value.multiviewGeometryShader << '\n';
+       s << "\tmultiviewTessellationShader = " << value.multiviewTessellationShader << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceMultiviewPropertiesKHX& value)
+{
+       s << "VkPhysicalDeviceMultiviewPropertiesKHX = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmaxMultiviewViewCount = " << value.maxMultiviewViewCount << '\n';
+       s << "\tmaxMultiviewInstanceIndex = " << value.maxMultiviewInstanceIndex << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryPropertiesKHR& value)
+{
+       s << "VkExternalMemoryPropertiesKHR = {\n";
+       s << "\texternalMemoryFeatures = " << getExternalMemoryFeatureFlagsKHRStr(value.externalMemoryFeatures) << '\n';
+       s << "\texportFromImportedHandleTypes = " << getExternalMemoryHandleTypeFlagsKHRStr(value.exportFromImportedHandleTypes) << '\n';
+       s << "\tcompatibleHandleTypes = " << getExternalMemoryHandleTypeFlagsKHRStr(value.compatibleHandleTypes) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalImageFormatInfoKHR& value)
+{
+       s << "VkPhysicalDeviceExternalImageFormatInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalImageFormatPropertiesKHR& value)
+{
+       s << "VkExternalImageFormatPropertiesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\texternalMemoryProperties = " << value.externalMemoryProperties << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalBufferInfoKHR& value)
+{
+       s << "VkPhysicalDeviceExternalBufferInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tflags = " << getBufferCreateFlagsStr(value.flags) << '\n';
+       s << "\tusage = " << getBufferUsageFlagsStr(value.usage) << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalBufferPropertiesKHR& value)
+{
+       s << "VkExternalBufferPropertiesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\texternalMemoryProperties = " << value.externalMemoryProperties << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceIDPropertiesKHR& value)
+{
+       s << "VkPhysicalDeviceIDPropertiesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tdeviceUUID = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.deviceUUID)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.deviceUUID))) << '\n';
+       s << "\tdriverUUID = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.driverUUID)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.driverUUID))) << '\n';
+       s << "\tdeviceLUID = " << '\n' << tcu::formatArray(tcu::Format::HexIterator<deUint8>(DE_ARRAY_BEGIN(value.deviceLUID)), tcu::Format::HexIterator<deUint8>(DE_ARRAY_END(value.deviceLUID))) << '\n';
+       s << "\tdeviceNodeMask = " << value.deviceNodeMask << '\n';
+       s << "\tdeviceLUIDValid = " << value.deviceLUIDValid << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryImageCreateInfoKHR& value)
+{
+       s << "VkExternalMemoryImageCreateInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsKHRStr(value.handleTypes) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalMemoryBufferCreateInfoKHR& value)
+{
+       s << "VkExternalMemoryBufferCreateInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsKHRStr(value.handleTypes) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportMemoryAllocateInfoKHR& value)
+{
+       s << "VkExportMemoryAllocateInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleTypes = " << getExternalMemoryHandleTypeFlagsKHRStr(value.handleTypes) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImportMemoryWin32HandleInfoKHR& value)
+{
+       s << "VkImportMemoryWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << "\thandle = " << value.handle << '\n';
+       s << "\tname = " << getCharPtrStr(value.name) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportMemoryWin32HandleInfoKHR& value)
+{
+       s << "VkExportMemoryWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tpAttributes = " << value.pAttributes << '\n';
+       s << "\tdwAccess = " << value.dwAccess << '\n';
+       s << "\tname = " << getCharPtrStr(value.name) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryWin32HandlePropertiesKHR& value)
+{
+       s << "VkMemoryWin32HandlePropertiesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmemoryTypeBits = " << value.memoryTypeBits << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryGetWin32HandleInfoKHR& value)
+{
+       s << "VkMemoryGetWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmemory = " << value.memory << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImportMemoryFdInfoKHR& value)
+{
+       s << "VkImportMemoryFdInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << "\tfd = " << value.fd << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryFdPropertiesKHR& value)
+{
+       s << "VkMemoryFdPropertiesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmemoryTypeBits = " << value.memoryTypeBits << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkMemoryGetFdInfoKHR& value)
+{
+       s << "VkMemoryGetFdInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tmemory = " << value.memory << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkWin32KeyedMutexAcquireReleaseInfoKHR& value)
+{
+       s << "VkWin32KeyedMutexAcquireReleaseInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tacquireCount = " << value.acquireCount << '\n';
+       s << "\tpAcquireSyncs = " << value.pAcquireSyncs << '\n';
+       s << "\tpAcquireKeys = " << value.pAcquireKeys << '\n';
+       s << "\tpAcquireTimeouts = " << value.pAcquireTimeouts << '\n';
+       s << "\treleaseCount = " << value.releaseCount << '\n';
+       s << "\tpReleaseSyncs = " << value.pReleaseSyncs << '\n';
+       s << "\tpReleaseKeys = " << value.pReleaseKeys << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceExternalSemaphoreInfoKHR& value)
+{
+       s << "VkPhysicalDeviceExternalSemaphoreInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExternalSemaphorePropertiesKHR& value)
+{
+       s << "VkExternalSemaphorePropertiesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\texportFromImportedHandleTypes = " << getExternalSemaphoreHandleTypeFlagsKHRStr(value.exportFromImportedHandleTypes) << '\n';
+       s << "\tcompatibleHandleTypes = " << getExternalSemaphoreHandleTypeFlagsKHRStr(value.compatibleHandleTypes) << '\n';
+       s << "\texternalSemaphoreFeatures = " << getExternalSemaphoreFeatureFlagsKHRStr(value.externalSemaphoreFeatures) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportSemaphoreCreateInfoKHR& value)
+{
+       s << "VkExportSemaphoreCreateInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\thandleTypes = " << getExternalSemaphoreHandleTypeFlagsKHRStr(value.handleTypes) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImportSemaphoreWin32HandleInfoKHR& value)
+{
+       s << "VkImportSemaphoreWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tsemaphore = " << value.semaphore << '\n';
+       s << "\tflags = " << getSemaphoreImportFlagsKHRStr(value.flags) << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << "\thandle = " << value.handle << '\n';
+       s << "\tname = " << getCharPtrStr(value.name) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkExportSemaphoreWin32HandleInfoKHR& value)
+{
+       s << "VkExportSemaphoreWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tpAttributes = " << value.pAttributes << '\n';
+       s << "\tdwAccess = " << value.dwAccess << '\n';
+       s << "\tname = " << getCharPtrStr(value.name) << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkD3D12FenceSubmitInfoKHR& value)
+{
+       s << "VkD3D12FenceSubmitInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\twaitSemaphoreValuesCount = " << value.waitSemaphoreValuesCount << '\n';
+       s << "\tpWaitSemaphoreValues = " << value.pWaitSemaphoreValues << '\n';
+       s << "\tsignalSemaphoreValuesCount = " << value.signalSemaphoreValuesCount << '\n';
+       s << "\tpSignalSemaphoreValues = " << value.pSignalSemaphoreValues << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSemaphoreGetWin32HandleInfoKHR& value)
+{
+       s << "VkSemaphoreGetWin32HandleInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tsemaphore = " << value.semaphore << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkImportSemaphoreFdInfoKHR& value)
+{
+       s << "VkImportSemaphoreFdInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tsemaphore = " << value.semaphore << '\n';
+       s << "\tflags = " << getSemaphoreImportFlagsKHRStr(value.flags) << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << "\tfd = " << value.fd << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkSemaphoreGetFdInfoKHR& value)
+{
+       s << "VkSemaphoreGetFdInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tsemaphore = " << value.semaphore << '\n';
+       s << "\thandleType = " << value.handleType << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkRefreshCycleDurationGOOGLE& value)
+{
+       s << "VkRefreshCycleDurationGOOGLE = {\n";
+       s << "\trefreshDuration = " << value.refreshDuration << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPastPresentationTimingGOOGLE& value)
+{
+       s << "VkPastPresentationTimingGOOGLE = {\n";
+       s << "\tpresentID = " << value.presentID << '\n';
+       s << "\tdesiredPresentTime = " << value.desiredPresentTime << '\n';
+       s << "\tactualPresentTime = " << value.actualPresentTime << '\n';
+       s << "\tearliestPresentTime = " << value.earliestPresentTime << '\n';
+       s << "\tpresentMargin = " << value.presentMargin << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPresentTimeGOOGLE& value)
+{
+       s << "VkPresentTimeGOOGLE = {\n";
+       s << "\tpresentID = " << value.presentID << '\n';
+       s << "\tdesiredPresentTime = " << value.desiredPresentTime << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPresentTimesInfoGOOGLE& value)
+{
+       s << "VkPresentTimesInfoGOOGLE = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tswapchainCount = " << value.swapchainCount << '\n';
+       s << "\tpTimes = " << value.pTimes << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkPhysicalDeviceVariablePointerFeaturesKHR& value)
+{
+       s << "VkPhysicalDeviceVariablePointerFeaturesKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tvariablePointersStorageBuffer = " << value.variablePointersStorageBuffer << '\n';
+       s << "\tvariablePointers = " << value.variablePointers << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkBindBufferMemoryInfoKHR& value)
+{
+       s << "VkBindBufferMemoryInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\tbuffer = " << value.buffer << '\n';
+       s << "\tmemory = " << value.memory << '\n';
+       s << "\tmemoryOffset = " << value.memoryOffset << '\n';
+       s << '}';
+       return s;
+}
+
+std::ostream& operator<< (std::ostream& s, const VkBindImageMemoryInfoKHR& value)
+{
+       s << "VkBindImageMemoryInfoKHR = {\n";
+       s << "\tsType = " << value.sType << '\n';
+       s << "\tpNext = " << value.pNext << '\n';
+       s << "\timage = " << value.image << '\n';
+       s << "\tmemory = " << value.memory << '\n';
+       s << "\tmemoryOffset = " << value.memoryOffset << '\n';
        s << '}';
        return s;
 }