From: Mark Lobodzinski Date: Tue, 30 May 2017 20:11:04 +0000 (-0600) Subject: layers: Pass layer data into PV validation functions X-Git-Tag: submit/tizen/20181227.054638~1121 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=28336d5b59e53c19a55fb03dac8087916bc3e2b9;p=platform%2Fupstream%2FVulkan-Tools.git layers: Pass layer data into PV validation functions Previously just passed in report data, but need access to more stuff. Change-Id: I2af7b2ae73d3e2ecd3409f32e8f1a42e5e736d8c --- diff --git a/layers/parameter_validation.cpp b/layers/parameter_validation.cpp index 0205f543..949d510d 100644 --- a/layers/parameter_validation.cpp +++ b/layers/parameter_validation.cpp @@ -263,7 +263,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *pCreat // Ordinarily we'd check these before calling down the chain, but none of the layer // support is in place until now, if we survive we can report the issue now. - parameter_validation_vkCreateInstance(my_instance_data->report_data, pCreateInfo, pAllocator, pInstance); + parameter_validation_vkCreateInstance(my_instance_data, pCreateInfo, pAllocator, pInstance); if (pCreateInfo->pApplicationInfo) { if (pCreateInfo->pApplicationInfo->pApplicationName) { @@ -304,7 +304,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocati } } - skip |= parameter_validation_vkDestroyInstance(my_data->report_data, pAllocator); + skip |= parameter_validation_vkDestroyInstance(my_data, pAllocator); // Disable and cleanup the temporary callback(s): if (callback_setup) { @@ -337,7 +337,7 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(VkInstance instance, uin auto my_data = GetLayerDataPtr(get_dispatch_key(instance), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkEnumeratePhysicalDevices(my_data->report_data, pPhysicalDeviceCount, pPhysicalDevices); + skip |= parameter_validation_vkEnumeratePhysicalDevices(my_data, pPhysicalDeviceCount, pPhysicalDevices); if (!skip) { result = my_data->dispatch_table.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); @@ -351,7 +351,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDe auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceFeatures(my_data->report_data, pFeatures); + skip |= parameter_validation_vkGetPhysicalDeviceFeatures(my_data, pFeatures); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceFeatures(physicalDevice, pFeatures); @@ -364,7 +364,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice ph auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties(my_data->report_data, format, pFormatProperties); + skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties(my_data, format, pFormatProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); @@ -380,7 +380,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(VkPhysical auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties(my_data->report_data, format, type, tiling, usage, flags, + skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties(my_data, format, type, tiling, usage, flags, pImageFormatProperties); if (!skip) { @@ -398,7 +398,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(VkPhysicalDevice physical auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceProperties(my_data->report_data, pProperties); + skip |= parameter_validation_vkGetPhysicalDeviceProperties(my_data, pProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceProperties(physicalDevice, pProperties); @@ -412,7 +412,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevi auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(my_data->report_data, pQueueFamilyPropertyCount, + skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties(my_data, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (!skip) { @@ -427,7 +427,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(VkPhysicalDevice ph auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties(my_data->report_data, pMemoryProperties); + skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties(my_data, pMemoryProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); @@ -560,7 +560,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice physicalDevice, con assert(my_instance_data != nullptr); std::unique_lock lock(global_lock); - skip |= parameter_validation_vkCreateDevice(my_instance_data->report_data, pCreateInfo, pAllocator, pDevice); + skip |= parameter_validation_vkCreateDevice(my_instance_data, pCreateInfo, pAllocator, pDevice); if (pCreateInfo != NULL) skip |= ValidateDeviceCreateInfo(my_instance_data, physicalDevice, pCreateInfo); @@ -629,7 +629,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCall layer_data *my_data = GetLayerDataPtr(key, layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyDevice(my_data->report_data, pAllocator); + skip |= parameter_validation_vkDestroyDevice(my_data, pAllocator); if (!skip) { layer_debug_report_destroy_device(device); @@ -670,7 +670,7 @@ VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(VkDevice device, uint32_t queueFamilyI assert(my_data != NULL); std::unique_lock lock(global_lock); - skip |= parameter_validation_vkGetDeviceQueue(my_data->report_data, queueFamilyIndex, queueIndex, pQueue); + skip |= parameter_validation_vkGetDeviceQueue(my_data, queueFamilyIndex, queueIndex, pQueue); if (!skip) { PreGetDeviceQueue(device, queueFamilyIndex, queueIndex); @@ -687,7 +687,7 @@ VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(VkQueue queue, uint32_t submitCount, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkQueueSubmit(my_data->report_data, submitCount, pSubmits, fence); + skip |= parameter_validation_vkQueueSubmit(my_data, submitCount, pSubmits, fence); if (!skip) { result = my_data->dispatch_table.QueueSubmit(queue, submitCount, pSubmits, fence); @@ -727,7 +727,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(VkDevice device, const VkMemoryAll layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkAllocateMemory(my_data->report_data, pAllocateInfo, pAllocator, pMemory); + skip |= parameter_validation_vkAllocateMemory(my_data, pAllocateInfo, pAllocator, pMemory); if (!skip) { result = my_data->dispatch_table.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); @@ -743,7 +743,7 @@ VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, co layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkFreeMemory(my_data->report_data, memory, pAllocator); + skip |= parameter_validation_vkFreeMemory(my_data, memory, pAllocator); if (!skip) { my_data->dispatch_table.FreeMemory(device, memory, pAllocator); @@ -757,7 +757,7 @@ VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkMapMemory(my_data->report_data, memory, offset, size, flags, ppData); + skip |= parameter_validation_vkMapMemory(my_data, memory, offset, size, flags, ppData); if (!skip) { result = my_data->dispatch_table.MapMemory(device, memory, offset, size, flags, ppData); @@ -773,7 +773,7 @@ VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory) { layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkUnmapMemory(my_data->report_data, memory); + skip |= parameter_validation_vkUnmapMemory(my_data, memory); if (!skip) { my_data->dispatch_table.UnmapMemory(device, memory); @@ -787,7 +787,7 @@ VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(VkDevice device, uint32_t layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkFlushMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges); + skip |= parameter_validation_vkFlushMappedMemoryRanges(my_data, memoryRangeCount, pMemoryRanges); if (!skip) { result = my_data->dispatch_table.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); @@ -805,7 +805,7 @@ VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(VkDevice device, uin layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkInvalidateMappedMemoryRanges(my_data->report_data, memoryRangeCount, pMemoryRanges); + skip |= parameter_validation_vkInvalidateMappedMemoryRanges(my_data, memoryRangeCount, pMemoryRanges); if (!skip) { result = my_data->dispatch_table.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); @@ -822,7 +822,7 @@ VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(VkDevice device, VkDeviceMe layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetDeviceMemoryCommitment(my_data->report_data, memory, pCommittedMemoryInBytes); + skip |= parameter_validation_vkGetDeviceMemoryCommitment(my_data, memory, pCommittedMemoryInBytes); if (!skip) { my_data->dispatch_table.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); @@ -836,7 +836,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkBindBufferMemory(my_data->report_data, buffer, memory, memoryOffset); + skip |= parameter_validation_vkBindBufferMemory(my_data, buffer, memory, memoryOffset); if (!skip) { result = my_data->dispatch_table.BindBufferMemory(device, buffer, memory, memoryOffset); @@ -853,7 +853,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(VkDevice device, VkImage image, V layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkBindImageMemory(my_data->report_data, image, memory, memoryOffset); + skip |= parameter_validation_vkBindImageMemory(my_data, image, memory, memoryOffset); if (!skip) { result = my_data->dispatch_table.BindImageMemory(device, image, memory, memoryOffset); @@ -870,7 +870,7 @@ VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(VkDevice device, VkBuffer layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetBufferMemoryRequirements(my_data->report_data, buffer, pMemoryRequirements); + skip |= parameter_validation_vkGetBufferMemoryRequirements(my_data, buffer, pMemoryRequirements); if (!skip) { my_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); @@ -882,7 +882,7 @@ VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(VkDevice device, VkImage i layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetImageMemoryRequirements(my_data->report_data, image, pMemoryRequirements); + skip |= parameter_validation_vkGetImageMemoryRequirements(my_data, image, pMemoryRequirements); if (!skip) { my_data->dispatch_table.GetImageMemoryRequirements(device, image, pMemoryRequirements); @@ -913,7 +913,7 @@ VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(VkDevice device, VkI layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetImageSparseMemoryRequirements(my_data->report_data, image, pSparseMemoryRequirementCount, + skip |= parameter_validation_vkGetImageSparseMemoryRequirements(my_data, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); if (!skip) { @@ -952,7 +952,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(VkPhysic auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(my_data->report_data, format, type, samples, usage, + skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties(my_data, format, type, samples, usage, tiling, pPropertyCount, pProperties); if (!skip) { @@ -971,7 +971,7 @@ VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(VkQueue queue, uint32_t bindInfoC layer_data *my_data = GetLayerDataPtr(get_dispatch_key(queue), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkQueueBindSparse(my_data->report_data, bindInfoCount, pBindInfo, fence); + skip |= parameter_validation_vkQueueBindSparse(my_data, bindInfoCount, pBindInfo, fence); if (!skip) { result = my_data->dispatch_table.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); @@ -989,7 +989,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateFence(VkDevice device, const VkFenceCreateI layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateFence(my_data->report_data, pCreateInfo, pAllocator, pFence); + skip |= parameter_validation_vkCreateFence(my_data, pCreateInfo, pAllocator, pFence); if (!skip) { result = my_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence); @@ -1005,7 +1005,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyFence(VkDevice device, VkFence fence, const Vk layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyFence(my_data->report_data, fence, pAllocator); + skip |= parameter_validation_vkDestroyFence(my_data, fence, pAllocator); if (!skip) { my_data->dispatch_table.DestroyFence(device, fence, pAllocator); @@ -1018,7 +1018,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetFences(VkDevice device, uint32_t fenceCount, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkResetFences(my_data->report_data, fenceCount, pFences); + skip |= parameter_validation_vkResetFences(my_data, fenceCount, pFences); if (!skip) { result = my_data->dispatch_table.ResetFences(device, fenceCount, pFences); @@ -1035,7 +1035,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(VkDevice device, VkFence fence) { layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetFenceStatus(my_data->report_data, fence); + skip |= parameter_validation_vkGetFenceStatus(my_data, fence); if (!skip) { result = my_data->dispatch_table.GetFenceStatus(device, fence); @@ -1053,7 +1053,7 @@ VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(VkDevice device, uint32_t fenceCoun layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkWaitForFences(my_data->report_data, fenceCount, pFences, waitAll, timeout); + skip |= parameter_validation_vkWaitForFences(my_data, fenceCount, pFences, waitAll, timeout); if (!skip) { result = my_data->dispatch_table.WaitForFences(device, fenceCount, pFences, waitAll, timeout); @@ -1071,7 +1071,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(VkDevice device, const VkSemaphor layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateSemaphore(my_data->report_data, pCreateInfo, pAllocator, pSemaphore); + skip |= parameter_validation_vkCreateSemaphore(my_data, pCreateInfo, pAllocator, pSemaphore); if (!skip) { result = my_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); @@ -1087,7 +1087,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySemaphore(VkDevice device, VkSemaphore semapho layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroySemaphore(my_data->report_data, semaphore, pAllocator); + skip |= parameter_validation_vkDestroySemaphore(my_data, semaphore, pAllocator); if (!skip) { my_data->dispatch_table.DestroySemaphore(device, semaphore, pAllocator); @@ -1101,7 +1101,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(VkDevice device, const VkEventCreateI layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateEvent(my_data->report_data, pCreateInfo, pAllocator, pEvent); + skip |= parameter_validation_vkCreateEvent(my_data, pCreateInfo, pAllocator, pEvent); if (!skip) { result = my_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent); @@ -1117,7 +1117,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyEvent(VkDevice device, VkEvent event, const Vk layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyEvent(my_data->report_data, event, pAllocator); + skip |= parameter_validation_vkDestroyEvent(my_data, event, pAllocator); if (!skip) { my_data->dispatch_table.DestroyEvent(device, event, pAllocator); @@ -1130,7 +1130,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(VkDevice device, VkEvent event) { layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetEventStatus(my_data->report_data, event); + skip |= parameter_validation_vkGetEventStatus(my_data, event); if (!skip) { result = my_data->dispatch_table.GetEventStatus(device, event); @@ -1147,7 +1147,7 @@ VKAPI_ATTR VkResult VKAPI_CALL SetEvent(VkDevice device, VkEvent event) { layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkSetEvent(my_data->report_data, event); + skip |= parameter_validation_vkSetEvent(my_data, event); if (!skip) { result = my_data->dispatch_table.SetEvent(device, event); @@ -1164,7 +1164,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(VkDevice device, VkEvent event) { layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkResetEvent(my_data->report_data, event); + skip |= parameter_validation_vkResetEvent(my_data, event); if (!skip) { result = my_data->dispatch_table.ResetEvent(device, event); @@ -1183,7 +1183,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(VkDevice device, const VkQueryPoo assert(device_data != nullptr); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkCreateQueryPool(device_data->report_data, pCreateInfo, pAllocator, pQueryPool); + skip |= parameter_validation_vkCreateQueryPool(device_data, pCreateInfo, pAllocator, pQueryPool); // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml if (pCreateInfo != nullptr) { @@ -1214,7 +1214,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(VkDevice device, VkQueryPool queryPo layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyQueryPool(my_data->report_data, queryPool, pAllocator); + skip |= parameter_validation_vkDestroyQueryPool(my_data, queryPool, pAllocator); if (!skip) { my_data->dispatch_table.DestroyQueryPool(device, queryPool, pAllocator); @@ -1228,7 +1228,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(VkDevice device, VkQueryPool layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dataSize, pData, + skip |= parameter_validation_vkGetQueryPoolResults(my_data, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); if (!skip) { @@ -1251,7 +1251,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(VkDevice device, const VkBufferCreat std::unique_lock lock(global_lock); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkCreateBuffer(report_data, pCreateInfo, pAllocator, pBuffer); + skip |= parameter_validation_vkCreateBuffer(device_data, pCreateInfo, pAllocator, pBuffer); if (pCreateInfo != nullptr) { // Buffer size must be greater than 0 (error 00663) @@ -1314,7 +1314,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyBuffer(my_data->report_data, buffer, pAllocator); + skip |= parameter_validation_vkDestroyBuffer(my_data, buffer, pAllocator); if (!skip) { my_data->dispatch_table.DestroyBuffer(device, buffer, pAllocator); @@ -1328,7 +1328,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(VkDevice device, const VkBufferV layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateBufferView(my_data->report_data, pCreateInfo, pAllocator, pView); + skip |= parameter_validation_vkCreateBufferView(my_data, pCreateInfo, pAllocator, pView); if (!skip) { result = my_data->dispatch_table.CreateBufferView(device, pCreateInfo, pAllocator, pView); @@ -1344,7 +1344,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyBufferView(VkDevice device, VkBufferView buffe layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyBufferView(my_data->report_data, bufferView, pAllocator); + skip |= parameter_validation_vkDestroyBufferView(my_data, bufferView, pAllocator); if (!skip) { my_data->dispatch_table.DestroyBufferView(device, bufferView, pAllocator); @@ -1361,7 +1361,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateI std::unique_lock lock(global_lock); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkCreateImage(report_data, pCreateInfo, pAllocator, pImage); + skip |= parameter_validation_vkCreateImage(device_data, pCreateInfo, pAllocator, pImage); if (pCreateInfo != nullptr) { @@ -1578,7 +1578,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const Vk layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyImage(my_data->report_data, image, pAllocator); + skip |= parameter_validation_vkDestroyImage(my_data, image, pAllocator); if (!skip) { my_data->dispatch_table.DestroyImage(device, image, pAllocator); @@ -1606,7 +1606,7 @@ VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(VkDevice device, VkImage im layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetImageSubresourceLayout(my_data->report_data, image, pSubresource, pLayout); + skip |= parameter_validation_vkGetImageSubresourceLayout(my_data, image, pSubresource, pLayout); if (!skip) { PreGetImageSubresourceLayout(device, pSubresource); @@ -1623,7 +1623,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageVie assert(my_data != NULL); debug_report_data *report_data = my_data->report_data; - skip |= parameter_validation_vkCreateImageView(report_data, pCreateInfo, pAllocator, pView); + skip |= parameter_validation_vkCreateImageView(my_data, pCreateInfo, pAllocator, pView); if (pCreateInfo != nullptr) { if ((pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_1D) || (pCreateInfo->viewType == VK_IMAGE_VIEW_TYPE_2D)) { @@ -1697,7 +1697,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyImageView(VkDevice device, VkImageView imageVi layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyImageView(my_data->report_data, imageView, pAllocator); + skip |= parameter_validation_vkDestroyImageView(my_data, imageView, pAllocator); if (!skip) { my_data->dispatch_table.DestroyImageView(device, imageView, pAllocator); @@ -1711,7 +1711,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShade layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateShaderModule(my_data->report_data, pCreateInfo, pAllocator, pShaderModule); + skip |= parameter_validation_vkCreateShaderModule(my_data, pCreateInfo, pAllocator, pShaderModule); if (!skip) { result = my_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); @@ -1728,7 +1728,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule s layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyShaderModule(my_data->report_data, shaderModule, pAllocator); + skip |= parameter_validation_vkDestroyShaderModule(my_data, shaderModule, pAllocator); if (!skip) { my_data->dispatch_table.DestroyShaderModule(device, shaderModule, pAllocator); @@ -1742,7 +1742,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(VkDevice device, const VkPipe layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreatePipelineCache(my_data->report_data, pCreateInfo, pAllocator, pPipelineCache); + skip |= parameter_validation_vkCreatePipelineCache(my_data, pCreateInfo, pAllocator, pPipelineCache); if (!skip) { result = my_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); @@ -1759,7 +1759,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(VkDevice device, VkPipelineCache layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyPipelineCache(my_data->report_data, pipelineCache, pAllocator); + skip |= parameter_validation_vkDestroyPipelineCache(my_data, pipelineCache, pAllocator); if (!skip) { my_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator); @@ -1773,7 +1773,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(VkDevice device, VkPipelineC layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPipelineCacheData(my_data->report_data, pipelineCache, pDataSize, pData); + skip |= parameter_validation_vkGetPipelineCacheData(my_data, pipelineCache, pDataSize, pData); if (!skip) { result = my_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData); @@ -1791,7 +1791,7 @@ VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(VkDevice device, VkPipelineCa layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkMergePipelineCaches(my_data->report_data, dstCache, srcCacheCount, pSrcCaches); + skip |= parameter_validation_vkMergePipelineCaches(my_data, dstCache, srcCacheCount, pSrcCaches); if (!skip) { result = my_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); @@ -1873,7 +1873,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipeli assert(device_data != nullptr); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkCreateGraphicsPipelines(report_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator, + skip |= parameter_validation_vkCreateGraphicsPipelines(device_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); if (pCreateInfos != nullptr) { @@ -2392,7 +2392,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(VkDevice device, VkPipelin layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateComputePipelines(my_data->report_data, pipelineCache, createInfoCount, pCreateInfos, + skip |= parameter_validation_vkCreateComputePipelines(my_data, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); skip |= PreCreateComputePipelines(device, pCreateInfos); @@ -2410,7 +2410,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipeline(VkDevice device, VkPipeline pipeline, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyPipeline(my_data->report_data, pipeline, pAllocator); + skip |= parameter_validation_vkDestroyPipeline(my_data, pipeline, pAllocator); if (!skip) { my_data->dispatch_table.DestroyPipeline(device, pipeline, pAllocator); @@ -2424,7 +2424,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(VkDevice device, const VkPip layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreatePipelineLayout(my_data->report_data, pCreateInfo, pAllocator, pPipelineLayout); + skip |= parameter_validation_vkCreatePipelineLayout(my_data, pCreateInfo, pAllocator, pPipelineLayout); if (!skip) { result = my_data->dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); @@ -2441,7 +2441,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(VkDevice device, VkPipelineLayo layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyPipelineLayout(my_data->report_data, pipelineLayout, pAllocator); + skip |= parameter_validation_vkDestroyPipelineLayout(my_data, pipelineLayout, pAllocator); if (!skip) { my_data->dispatch_table.DestroyPipelineLayout(device, pipelineLayout, pAllocator); @@ -2456,7 +2456,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(VkDevice device, const VkSamplerCre assert(device_data != NULL); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkCreateSampler(report_data, pCreateInfo, pAllocator, pSampler); + skip |= parameter_validation_vkCreateSampler(device_data, pCreateInfo, pAllocator, pSampler); if (pCreateInfo != nullptr) { @@ -2498,7 +2498,7 @@ VKAPI_ATTR void VKAPI_CALL DestroySampler(VkDevice device, VkSampler sampler, co layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroySampler(my_data->report_data, sampler, pAllocator); + skip |= parameter_validation_vkDestroySampler(my_data, sampler, pAllocator); if (!skip) { my_data->dispatch_table.DestroySampler(device, sampler, pAllocator); @@ -2514,7 +2514,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(VkDevice device, const assert(device_data != nullptr); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkCreateDescriptorSetLayout(report_data, pCreateInfo, pAllocator, pSetLayout); + skip |= parameter_validation_vkCreateDescriptorSetLayout(device_data, pCreateInfo, pAllocator, pSetLayout); // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml if ((pCreateInfo != nullptr) && (pCreateInfo->pBindings != nullptr)) { @@ -2568,7 +2568,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(VkDevice device, VkDescrip layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyDescriptorSetLayout(my_data->report_data, descriptorSetLayout, pAllocator); + skip |= parameter_validation_vkDestroyDescriptorSetLayout(my_data, descriptorSetLayout, pAllocator); if (!skip) { my_data->dispatch_table.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); @@ -2582,7 +2582,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(VkDevice device, const VkDes layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateDescriptorPool(my_data->report_data, pCreateInfo, pAllocator, pDescriptorPool); + skip |= parameter_validation_vkCreateDescriptorPool(my_data, pCreateInfo, pAllocator, pDescriptorPool); /* TODOVV: How do we validate maxSets? Probably belongs in the limits layer? */ @@ -2601,7 +2601,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(VkDevice device, VkDescriptorPo layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyDescriptorPool(my_data->report_data, descriptorPool, pAllocator); + skip |= parameter_validation_vkDestroyDescriptorPool(my_data, descriptorPool, pAllocator); if (!skip) { my_data->dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator); @@ -2615,7 +2615,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(VkDevice device, VkDescriptor layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkResetDescriptorPool(my_data->report_data, descriptorPool, flags); + skip |= parameter_validation_vkResetDescriptorPool(my_data, descriptorPool, flags); if (!skip) { result = my_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags); @@ -2633,7 +2633,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(VkDevice device, const VkD layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkAllocateDescriptorSets(my_data->report_data, pAllocateInfo, pDescriptorSets); + skip |= parameter_validation_vkAllocateDescriptorSets(my_data, pAllocateInfo, pDescriptorSets); if (!skip) { result = my_data->dispatch_table.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); @@ -2652,7 +2652,7 @@ VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(VkDevice device, VkDescriptorP assert(device_data != nullptr); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkFreeDescriptorSets(report_data, descriptorPool, descriptorSetCount, pDescriptorSets); + skip |= parameter_validation_vkFreeDescriptorSets(device_data, descriptorPool, descriptorSetCount, pDescriptorSets); // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond @@ -2677,7 +2677,7 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t descri assert(device_data != NULL); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkUpdateDescriptorSets(report_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, + skip |= parameter_validation_vkUpdateDescriptorSets(device_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml @@ -2824,7 +2824,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(VkDevice device, const VkFrameb layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateFramebuffer(my_data->report_data, pCreateInfo, pAllocator, pFramebuffer); + skip |= parameter_validation_vkCreateFramebuffer(my_data, pCreateInfo, pAllocator, pFramebuffer); if (!skip) { result = my_data->dispatch_table.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); @@ -2840,7 +2840,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(VkDevice device, VkFramebuffer fra layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyFramebuffer(my_data->report_data, framebuffer, pAllocator); + skip |= parameter_validation_vkDestroyFramebuffer(my_data, framebuffer, pAllocator); if (!skip) { my_data->dispatch_table.DestroyFramebuffer(device, framebuffer, pAllocator); @@ -2880,7 +2880,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(VkDevice device, const VkRenderP layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCreateRenderPass(my_data->report_data, pCreateInfo, pAllocator, pRenderPass); + skip |= parameter_validation_vkCreateRenderPass(my_data, pCreateInfo, pAllocator, pRenderPass); skip |= PreCreateRenderPass(my_data, pCreateInfo); if (!skip) { @@ -2897,7 +2897,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(VkDevice device, VkRenderPass rende layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyRenderPass(my_data->report_data, renderPass, pAllocator); + skip |= parameter_validation_vkDestroyRenderPass(my_data, renderPass, pAllocator); if (!skip) { my_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator); @@ -2909,7 +2909,7 @@ VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(VkDevice device, VkRenderPas layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetRenderAreaGranularity(my_data->report_data, renderPass, pGranularity); + skip |= parameter_validation_vkGetRenderAreaGranularity(my_data, renderPass, pGranularity); if (!skip) { my_data->dispatch_table.GetRenderAreaGranularity(device, renderPass, pGranularity); @@ -2926,7 +2926,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(VkDevice device, const VkComman skip |= ValidateDeviceQueueFamily(my_data, pCreateInfo->queueFamilyIndex, "vkCreateCommandPool", "pCreateInfo->queueFamilyIndex", VALIDATION_ERROR_02c0004e); - skip |= parameter_validation_vkCreateCommandPool(my_data->report_data, pCreateInfo, pAllocator, pCommandPool); + skip |= parameter_validation_vkCreateCommandPool(my_data, pCreateInfo, pAllocator, pCommandPool); if (!skip) { result = my_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); @@ -2942,7 +2942,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool com layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkDestroyCommandPool(my_data->report_data, commandPool, pAllocator); + skip |= parameter_validation_vkDestroyCommandPool(my_data, commandPool, pAllocator); if (!skip) { my_data->dispatch_table.DestroyCommandPool(device, commandPool, pAllocator); @@ -2955,7 +2955,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool c layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkResetCommandPool(my_data->report_data, commandPool, flags); + skip |= parameter_validation_vkResetCommandPool(my_data, commandPool, flags); if (!skip) { result = my_data->dispatch_table.ResetCommandPool(device, commandPool, flags); @@ -2973,7 +2973,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkC layer_data *my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkAllocateCommandBuffers(my_data->report_data, pAllocateInfo, pCommandBuffers); + skip |= parameter_validation_vkAllocateCommandBuffers(my_data, pAllocateInfo, pCommandBuffers); if (!skip) { result = my_data->dispatch_table.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); @@ -2991,7 +2991,7 @@ VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool com assert(device_data != nullptr); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkFreeCommandBuffers(report_data, commandPool, commandBufferCount, pCommandBuffers); + skip |= parameter_validation_vkFreeCommandBuffers(device_data, commandPool, commandBufferCount, pCommandBuffers); // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml // This is an array of handles, where the elements are allowed to be VK_NULL_HANDLE, and does not require any validation beyond @@ -3032,7 +3032,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer commandBuffer, assert(device_data != nullptr); debug_report_data *report_data = device_data->report_data; - skip |= parameter_validation_vkBeginCommandBuffer(report_data, pBeginInfo); + skip |= parameter_validation_vkBeginCommandBuffer(device_data, pBeginInfo); // Validation for parameters excluded from the generated validation code due to a 'noautovalidity' tag in vk.xml // TODO: pBeginInfo->pInheritanceInfo must not be NULL if commandBuffer is a secondary command buffer @@ -3084,7 +3084,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer commandBuffer, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - bool skip = parameter_validation_vkResetCommandBuffer(my_data->report_data, flags); + bool skip = parameter_validation_vkResetCommandBuffer(my_data, flags); if (!skip) { result = my_data->dispatch_table.ResetCommandBuffer(commandBuffer, flags); @@ -3101,7 +3101,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipe layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdBindPipeline(my_data->report_data, pipelineBindPoint, pipeline); + skip |= parameter_validation_vkCmdBindPipeline(my_data, pipelineBindPoint, pipeline); if (!skip) { my_data->dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); @@ -3212,7 +3212,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t assert(my_data != NULL); debug_report_data *report_data = my_data->report_data; - skip |= parameter_validation_vkCmdSetScissor(my_data->report_data, firstScissor, scissorCount, pScissors); + skip |= parameter_validation_vkCmdSetScissor(my_data, firstScissor, scissorCount, pScissors); if (my_data->physical_device_features.multiViewport == false) { if (scissorCount != 1) { @@ -3276,7 +3276,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(VkCommandBuffer commandBuffer, c layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdSetBlendConstants(my_data->report_data, blendConstants); + skip |= parameter_validation_vkCmdSetBlendConstants(my_data, blendConstants); if (!skip) { my_data->dispatch_table.CmdSetBlendConstants(commandBuffer, blendConstants); @@ -3294,7 +3294,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(VkCommandBuffer commandBuffe layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdSetStencilCompareMask(my_data->report_data, faceMask, compareMask); + skip |= parameter_validation_vkCmdSetStencilCompareMask(my_data, faceMask, compareMask); if (!skip) { my_data->dispatch_table.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); @@ -3306,7 +3306,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdSetStencilWriteMask(my_data->report_data, faceMask, writeMask); + skip |= parameter_validation_vkCmdSetStencilWriteMask(my_data, faceMask, writeMask); if (!skip) { my_data->dispatch_table.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); @@ -3318,7 +3318,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(VkCommandBuffer commandBuffer, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdSetStencilReference(my_data->report_data, faceMask, reference); + skip |= parameter_validation_vkCmdSetStencilReference(my_data, faceMask, reference); if (!skip) { my_data->dispatch_table.CmdSetStencilReference(commandBuffer, faceMask, reference); @@ -3333,7 +3333,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(VkCommandBuffer commandBuffer, layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdBindDescriptorSets(my_data->report_data, pipelineBindPoint, layout, firstSet, + skip |= parameter_validation_vkCmdBindDescriptorSets(my_data, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); if (!skip) { @@ -3348,7 +3348,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkB layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdBindIndexBuffer(my_data->report_data, buffer, offset, indexType); + skip |= parameter_validation_vkCmdBindIndexBuffer(my_data, buffer, offset, indexType); if (!skip) { my_data->dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); @@ -3361,7 +3361,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer commandBuffer, u layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdBindVertexBuffers(my_data->report_data, firstBinding, bindingCount, pBuffers, pOffsets); + skip |= parameter_validation_vkCmdBindVertexBuffers(my_data, firstBinding, bindingCount, pBuffers, pOffsets); if (!skip) { my_data->dispatch_table.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); @@ -3415,7 +3415,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuff DEVICE_FEATURE, LayerName, "CmdDrawIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count); } - skip |= parameter_validation_vkCmdDrawIndirect(my_data->report_data, buffer, offset, count, stride); + skip |= parameter_validation_vkCmdDrawIndirect(my_data, buffer, offset, count, stride); if (!skip) { my_data->dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, count, stride); @@ -3433,7 +3433,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, DEVICE_FEATURE, LayerName, "CmdDrawIndexedIndirect(): Device feature multiDrawIndirect disabled: count must be 0 or 1 but is %d", count); } - skip |= parameter_validation_vkCmdDrawIndexedIndirect(my_data->report_data, buffer, offset, count, stride); + skip |= parameter_validation_vkCmdDrawIndexedIndirect(my_data, buffer, offset, count, stride); if (!skip) { my_data->dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride); @@ -3450,7 +3450,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(VkCommandBuffer commandBuffer, Vk layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdDispatchIndirect(my_data->report_data, buffer, offset); + skip |= parameter_validation_vkCmdDispatchIndirect(my_data, buffer, offset); if (!skip) { my_data->dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset); @@ -3463,7 +3463,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdCopyBuffer(my_data->report_data, srcBuffer, dstBuffer, regionCount, pRegions); + skip |= parameter_validation_vkCmdCopyBuffer(my_data, srcBuffer, dstBuffer, regionCount, pRegions); if (!skip) { my_data->dispatch_table.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); @@ -3503,7 +3503,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer commandBuffer, VkImage s layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdCopyImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, + skip |= parameter_validation_vkCmdCopyImage(my_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); if (!skip) { @@ -3543,7 +3543,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBlitImage(VkCommandBuffer commandBuffer, VkImage s layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdBlitImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, + skip |= parameter_validation_vkCmdBlitImage(my_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); if (!skip) { @@ -3577,7 +3577,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer commandBuffer, V layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdCopyBufferToImage(my_data->report_data, srcBuffer, dstImage, dstImageLayout, regionCount, + skip |= parameter_validation_vkCmdCopyBufferToImage(my_data, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); if (!skip) { @@ -3609,7 +3609,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, V layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdCopyImageToBuffer(my_data->report_data, srcImage, srcImageLayout, dstBuffer, regionCount, + skip |= parameter_validation_vkCmdCopyImageToBuffer(my_data, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); if (!skip) { @@ -3625,7 +3625,7 @@ VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuff layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdUpdateBuffer(my_data->report_data, dstBuffer, dstOffset, dataSize, pData); + skip |= parameter_validation_vkCmdUpdateBuffer(my_data, dstBuffer, dstOffset, dataSize, pData); if (dstOffset & 3) { skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__, @@ -3658,7 +3658,7 @@ VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdFillBuffer(my_data->report_data, dstBuffer, dstOffset, size, data); + skip |= parameter_validation_vkCmdFillBuffer(my_data, dstBuffer, dstOffset, size, data); if (dstOffset & 3) { skip |= log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0, __LINE__, @@ -3693,7 +3693,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(VkCommandBuffer commandBuffer, VkI layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdClearColorImage(my_data->report_data, image, imageLayout, pColor, rangeCount, pRanges); + skip |= parameter_validation_vkCmdClearColorImage(my_data, image, imageLayout, pColor, rangeCount, pRanges); if (!skip) { my_data->dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); @@ -3707,7 +3707,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(VkCommandBuffer commandBuff layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdClearDepthStencilImage(my_data->report_data, image, imageLayout, pDepthStencil, rangeCount, + skip |= parameter_validation_vkCmdClearDepthStencilImage(my_data, image, imageLayout, pDepthStencil, rangeCount, pRanges); if (!skip) { @@ -3722,7 +3722,7 @@ VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(VkCommandBuffer commandBuffer, ui layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdClearAttachments(my_data->report_data, attachmentCount, pAttachments, rectCount, pRects); + skip |= parameter_validation_vkCmdClearAttachments(my_data, attachmentCount, pAttachments, rectCount, pRects); if (!skip) { my_data->dispatch_table.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); @@ -3760,7 +3760,7 @@ VKAPI_ATTR void VKAPI_CALL CmdResolveImage(VkCommandBuffer commandBuffer, VkImag layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdResolveImage(my_data->report_data, srcImage, srcImageLayout, dstImage, dstImageLayout, + skip |= parameter_validation_vkCmdResolveImage(my_data, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); if (!skip) { @@ -3776,7 +3776,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent ev layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdSetEvent(my_data->report_data, event, stageMask); + skip |= parameter_validation_vkCmdSetEvent(my_data, event, stageMask); if (!skip) { my_data->dispatch_table.CmdSetEvent(commandBuffer, event, stageMask); @@ -3788,7 +3788,7 @@ VKAPI_ATTR void VKAPI_CALL CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdResetEvent(my_data->report_data, event, stageMask); + skip |= parameter_validation_vkCmdResetEvent(my_data, event, stageMask); if (!skip) { my_data->dispatch_table.CmdResetEvent(commandBuffer, event, stageMask); @@ -3804,7 +3804,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdWaitEvents(my_data->report_data, eventCount, pEvents, srcStageMask, dstStageMask, + skip |= parameter_validation_vkCmdWaitEvents(my_data, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); @@ -3824,7 +3824,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkP layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdPipelineBarrier(my_data->report_data, srcStageMask, dstStageMask, dependencyFlags, + skip |= parameter_validation_vkCmdPipelineBarrier(my_data, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); @@ -3841,7 +3841,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryP layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdBeginQuery(my_data->report_data, queryPool, slot, flags); + skip |= parameter_validation_vkCmdBeginQuery(my_data, queryPool, slot, flags); if (!skip) { my_data->dispatch_table.CmdBeginQuery(commandBuffer, queryPool, slot, flags); @@ -3853,7 +3853,7 @@ VKAPI_ATTR void VKAPI_CALL CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPoo layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdEndQuery(my_data->report_data, queryPool, slot); + skip |= parameter_validation_vkCmdEndQuery(my_data, queryPool, slot); if (!skip) { my_data->dispatch_table.CmdEndQuery(commandBuffer, queryPool, slot); @@ -3866,7 +3866,7 @@ VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQu layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdResetQueryPool(my_data->report_data, queryPool, firstQuery, queryCount); + skip |= parameter_validation_vkCmdResetQueryPool(my_data, queryPool, firstQuery, queryCount); if (!skip) { my_data->dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); @@ -3879,7 +3879,7 @@ VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPi layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdWriteTimestamp(my_data->report_data, pipelineStage, queryPool, query); + skip |= parameter_validation_vkCmdWriteTimestamp(my_data, pipelineStage, queryPool, query); if (!skip) { my_data->dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); @@ -3893,7 +3893,7 @@ VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdCopyQueryPoolResults(my_data->report_data, queryPool, firstQuery, queryCount, dstBuffer, + skip |= parameter_validation_vkCmdCopyQueryPoolResults(my_data, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); if (!skip) { @@ -3908,7 +3908,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPushConstants(VkCommandBuffer commandBuffer, VkPip layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdPushConstants(my_data->report_data, layout, stageFlags, offset, size, pValues); + skip |= parameter_validation_vkCmdPushConstants(my_data, layout, stageFlags, offset, size, pValues); if (!skip) { my_data->dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); @@ -3921,7 +3921,7 @@ VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(VkCommandBuffer commandBuffer, con layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdBeginRenderPass(my_data->report_data, pRenderPassBegin, contents); + skip |= parameter_validation_vkCmdBeginRenderPass(my_data, pRenderPassBegin, contents); if (!skip) { my_data->dispatch_table.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); @@ -3933,7 +3933,7 @@ VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpa layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdNextSubpass(my_data->report_data, contents); + skip |= parameter_validation_vkCmdNextSubpass(my_data, contents); if (!skip) { my_data->dispatch_table.CmdNextSubpass(commandBuffer, contents); @@ -3951,7 +3951,7 @@ VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(VkCommandBuffer commandBuffer, uin layer_data *my_data = GetLayerDataPtr(get_dispatch_key(commandBuffer), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkCmdExecuteCommands(my_data->report_data, commandBufferCount, pCommandBuffers); + skip |= parameter_validation_vkCmdExecuteCommands(my_data, commandBufferCount, pCommandBuffers); if (!skip) { my_data->dispatch_table.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); @@ -4011,7 +4011,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(VkDevice device, const VkSwapc skip |= require_device_extension(device_data, device_data->enables.khr_swapchain, "vkCreateSwapchainKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); - skip |= parameter_validation_vkCreateSwapchainKHR(device_data->report_data, pCreateInfo, pAllocator, pSwapchain); + skip |= parameter_validation_vkCreateSwapchainKHR(device_data, pCreateInfo, pAllocator, pSwapchain); if (pCreateInfo != nullptr) { if ((device_data->physical_device_features.textureCompressionETC2 == false) && @@ -4096,7 +4096,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(VkDevice device, VkSwapchai skip |= require_device_extension(my_data, my_data->enables.khr_swapchain, "vkGetSwapchainImagesKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); - skip |= parameter_validation_vkGetSwapchainImagesKHR(my_data->report_data, swapchain, pSwapchainImageCount, pSwapchainImages); + skip |= parameter_validation_vkGetSwapchainImagesKHR(my_data, swapchain, pSwapchainImageCount, pSwapchainImages); if (!skip) { result = my_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); @@ -4117,7 +4117,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(VkDevice device, VkSwapchainK skip |= require_device_extension(my_data, my_data->enables.khr_swapchain, "vkAcquireNextImageKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); - skip |= parameter_validation_vkAcquireNextImageKHR(my_data->report_data, swapchain, timeout, semaphore, fence, pImageIndex); + skip |= parameter_validation_vkAcquireNextImageKHR(my_data, swapchain, timeout, semaphore, fence, pImageIndex); if (!skip) { result = my_data->dispatch_table.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); @@ -4137,7 +4137,7 @@ VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(VkQueue queue, const VkPresentInf skip |= require_device_extension(my_data, my_data->enables.khr_swapchain, "vkQueuePresentKHR", VK_KHR_SWAPCHAIN_EXTENSION_NAME); - skip |= parameter_validation_vkQueuePresentKHR(my_data->report_data, pPresentInfo); + skip |= parameter_validation_vkQueuePresentKHR(my_data, pPresentInfo); if (pPresentInfo && pPresentInfo->pNext) { // Verify ext struct @@ -4221,7 +4221,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevi skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface, "vkGetPhysicalDeviceSurfaceSupportKHR", VK_KHR_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(my_data->report_data, queueFamilyIndex, surface, pSupported); + skip |= parameter_validation_vkGetPhysicalDeviceSurfaceSupportKHR(my_data, queueFamilyIndex, surface, pSupported); if (!skip) { result = my_data->dispatch_table.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); @@ -4242,7 +4242,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysica skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", VK_KHR_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(my_data->report_data, surface, pSurfaceCapabilities); + skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(my_data, surface, pSurfaceCapabilities); if (!skip) { result = my_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); @@ -4264,7 +4264,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevi skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface, "vkGetPhysicalDeviceSurfaceFormatsKHR", VK_KHR_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR(my_data->report_data, surface, pSurfaceFormatCount, + skip |= parameter_validation_vkGetPhysicalDeviceSurfaceFormatsKHR(my_data, surface, pSurfaceFormatCount, pSurfaceFormats); if (!skip) { @@ -4288,7 +4288,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(VkPhysica skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_surface, "vkGetPhysicalDeviceSurfacePresentModesKHR", VK_KHR_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR(my_data->report_data, surface, pPresentModeCount, + skip |= parameter_validation_vkGetPhysicalDeviceSurfacePresentModesKHR(my_data, surface, pPresentModeCount, pPresentModes); if (!skip) { @@ -4331,7 +4331,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(VkInstance instance, const validation_error_map[VALIDATION_ERROR_15a00a38]); } - skip |= parameter_validation_vkCreateWin32SurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface); + skip |= parameter_validation_vkCreateWin32SurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface); if (!skip) { result = my_data->dispatch_table.CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); @@ -4376,7 +4376,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(VkInstance instance, const Vk skip |= require_instance_extension(instance, &InstanceExtensions::khr_xcb_surface, "vkCreateXcbSurfaceKHR", VK_KHR_XCB_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkCreateXcbSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface); + skip |= parameter_validation_vkCreateXcbSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface); if (!skip) { result = my_data->dispatch_table.CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); @@ -4399,7 +4399,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(VkPhys skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_xcb_surface, "vkGetPhysicalDeviceXcbPresentationSupportKHR", VK_KHR_XCB_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(my_data->report_data, queueFamilyIndex, connection, + skip |= parameter_validation_vkGetPhysicalDeviceXcbPresentationSupportKHR(my_data, queueFamilyIndex, connection, visual_id); if (!skip) { @@ -4423,7 +4423,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(VkInstance instance, const V skip |= require_instance_extension(instance, &InstanceExtensions::khr_xlib_surface, "vkCreateXlibSurfaceKHR", VK_KHR_XLIB_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkCreateXlibSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface); + skip |= parameter_validation_vkCreateXlibSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface); if (!skip) { result = my_data->dispatch_table.CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); @@ -4447,7 +4447,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(VkPhy "vkGetPhysicalDeviceXlibPresentationSupportKHR", VK_KHR_XLIB_SURFACE_EXTENSION_NAME); skip |= - parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(my_data->report_data, queueFamilyIndex, dpy, visualID); + parameter_validation_vkGetPhysicalDeviceXlibPresentationSupportKHR(my_data, queueFamilyIndex, dpy, visualID); if (!skip) { result = @@ -4469,7 +4469,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateMirSurfaceKHR(VkInstance instance, const Vk skip |= require_instance_extension(instance, &InstanceExtensions::khr_mir_surface, "vkCreateMirSurfaceKHR", VK_KHR_MIR_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkCreateMirSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface); + skip |= parameter_validation_vkCreateMirSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface); if (!skip) { result = my_data->dispatch_table.CreateMirSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); @@ -4492,7 +4492,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceMirPresentationSupportKHR(VkPhys skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_mir_surface, "vkGetPhysicalDeviceMirPresentationSupportKHR", VK_KHR_MIR_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR(my_data->report_data, queueFamilyIndex, connection); + skip |= parameter_validation_vkGetPhysicalDeviceMirPresentationSupportKHR(my_data, queueFamilyIndex, connection); if (!skip) { result = my_data->dispatch_table.GetPhysicalDeviceMirPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection); @@ -4513,7 +4513,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(VkInstance instance, cons skip |= require_instance_extension(instance, &InstanceExtensions::khr_wayland_surface, "vkCreateWaylandSurfaceKHR", VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkCreateWaylandSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface); + skip |= parameter_validation_vkCreateWaylandSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface); if (!skip) { result = my_data->dispatch_table.CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); @@ -4536,7 +4536,7 @@ VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(Vk skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_wayland_surface, "vkGetPhysicalDeviceWaylandPresentationSupportKHR", VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(my_data->report_data, queueFamilyIndex, display); + skip |= parameter_validation_vkGetPhysicalDeviceWaylandPresentationSupportKHR(my_data, queueFamilyIndex, display); if (!skip) { result = my_data->dispatch_table.GetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); @@ -4558,7 +4558,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(VkInstance instance, cons skip |= require_instance_extension(instance, &InstanceExtensions::khr_android_surface, "vkCreateAndroidSurfaceKHR", VK_KHR_ANDROID_SURFACE_EXTENSION_NAME); - skip |= parameter_validation_vkCreateAndroidSurfaceKHR(my_data->report_data, pCreateInfo, pAllocator, pSurface); + skip |= parameter_validation_vkCreateAndroidSurfaceKHR(my_data, pCreateInfo, pAllocator, pSurface); if (!skip) { result = my_data->dispatch_table.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); @@ -4581,7 +4581,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(VkDevice device, uint32 skip |= require_device_extension(my_data, my_data->enables.khr_display_swapchain, "vkCreateSharedSwapchainsKHR", VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME); - skip |= parameter_validation_vkCreateSharedSwapchainsKHR(my_data->report_data, swapchainCount, pCreateInfos, pAllocator, + skip |= parameter_validation_vkCreateSharedSwapchainsKHR(my_data, swapchainCount, pCreateInfos, pAllocator, pSwapchains); if (!skip) { @@ -4751,7 +4751,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physic skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_get_physical_device_properties2, "vkGetPhysicalDeviceFeatures2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceFeatures2KHR(my_data->report_data, pFeatures); + skip |= parameter_validation_vkGetPhysicalDeviceFeatures2KHR(my_data, pFeatures); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); @@ -4767,7 +4767,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(VkPhysicalDevice phys skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khr_get_physical_device_properties2, "vkGetPhysicalDeviceProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceProperties2KHR(my_data->report_data, pProperties); + skip |= parameter_validation_vkGetPhysicalDeviceProperties2KHR(my_data, pProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); @@ -4784,7 +4784,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevic "vkGetPhysicalDeviceFormatProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties2KHR(my_data->report_data, format, pFormatProperties); + skip |= parameter_validation_vkGetPhysicalDeviceFormatProperties2KHR(my_data, format, pFormatProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); @@ -4803,7 +4803,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( "vkGetPhysicalDeviceImageFormatProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties2KHR(my_data->report_data, pImageFormatInfo, + skip |= parameter_validation_vkGetPhysicalDeviceImageFormatProperties2KHR(my_data, pImageFormatInfo, pImageFormatProperties); if (!skip) { @@ -4827,7 +4827,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysical "vkGetPhysicalDeviceQueueFamilyProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties2KHR(my_data->report_data, pQueueFamilyPropertyCount, + skip |= parameter_validation_vkGetPhysicalDeviceQueueFamilyProperties2KHR(my_data, pQueueFamilyPropertyCount, pQueueFamilyProperties); if (!skip) { @@ -4846,7 +4846,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevic "vkGetPhysicalDeviceMemoryProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties2KHR(my_data->report_data, pMemoryProperties); + skip |= parameter_validation_vkGetPhysicalDeviceMemoryProperties2KHR(my_data, pMemoryProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); @@ -4886,7 +4886,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( "vkGetPhysicalDeviceSparseImageFormatProperties2KHR", VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(my_data->report_data, pFormatInfo, + skip |= parameter_validation_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(my_data, pFormatInfo, pPropertyCount, pProperties); if (!skip) { @@ -4906,7 +4906,7 @@ VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(VkDevice device, VkCommandPool com skip |= require_device_extension(my_data, my_data->enables.khr_maintenance1, "vkTrimCommandPoolKHR", VK_KHR_MAINTENANCE1_EXTENSION_NAME); - skip |= parameter_validation_vkTrimCommandPoolKHR(my_data->report_data, commandPool, flags); + skip |= parameter_validation_vkTrimCommandPoolKHR(my_data, commandPool, flags); if (!skip) { my_data->dispatch_table.TrimCommandPoolKHR(device, commandPool, flags); @@ -4925,7 +4925,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer skip |= require_device_extension(my_data, my_data->enables.khr_push_descriptor, "vkCmdPushDescriptorSetKHR", VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME); - skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data->report_data, pipelineBindPoint, layout, set, + skip |= parameter_validation_vkCmdPushDescriptorSetKHR(my_data, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); if (!skip) { @@ -4948,7 +4948,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(VkDevice device skip |= require_device_extension(my_data, my_data->enables.khr_descriptor_update_template, "vkCreateDescriptorUpdateTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME); - skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data->report_data, pCreateInfo, pAllocator, + skip |= parameter_validation_vkCreateDescriptorUpdateTemplateKHR(my_data, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); if (!skip) { @@ -4971,7 +4971,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(VkDevice device, "vkDestroyDescriptorUpdateTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME); #if 0 // Validation not automatically generated - skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data->report_data, descriptorUpdateTemplate, + skip |= parameter_validation_vkDestroyDescriptorUpdateTemplateKHR(my_data, descriptorUpdateTemplate, pAllocator); #endif @@ -4990,7 +4990,7 @@ VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(VkDevice device, V skip |= require_device_extension(my_data, my_data->enables.khr_descriptor_update_template, "vkUpdateDescriptorSetWithTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME); - skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data->report_data, descriptorSet, descriptorUpdateTemplate, + skip |= parameter_validation_vkUpdateDescriptorSetWithTemplateKHR(my_data, descriptorSet, descriptorUpdateTemplate, pData); if (!skip) { @@ -5008,7 +5008,7 @@ VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer c skip |= require_device_extension(my_data, my_data->enables.khr_descriptor_update_template, "vkCmdPushDescriptorSetWithTemplateKHR", VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME); - skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data->report_data, descriptorUpdateTemplate, layout, set, + skip |= parameter_validation_vkCmdPushDescriptorSetWithTemplateKHR(my_data, descriptorUpdateTemplate, layout, set, pData); if (!skip) { @@ -5021,7 +5021,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(VkDevice device, VkSwapchai layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data->report_data, swapchain); + skip = parameter_validation_vkGetSwapchainStatusKHR(dev_data, swapchain); if (!skip) { result = dev_data->dispatch_table.GetSwapchainStatusKHR(device, swapchain); @@ -5036,7 +5036,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysic instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data->report_data, pSurfaceInfo, + skip = parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2KHR(instance_data, pSurfaceInfo, pSurfaceCapabilities); if (!skip) { @@ -5053,7 +5053,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDev bool skip = false; instance_layer_data *instance_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); VkResult result = VK_ERROR_VALIDATION_FAILED_EXT; - skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data->report_data, pSurfaceInfo, pSurfaceFormatCount, + skip = parameter_validation_vkGetPhysicalDeviceSurfaceFormats2KHR(instance_data, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); if (!skip) { result = instance_data->dispatch_table.GetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, @@ -5074,7 +5074,7 @@ VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHX( skip |= require_instance_extension(instance, &InstanceExtensions::khx_device_group_creation, "vkEnumeratePhysicalDeviceGroupsKHX", VK_KHX_DEVICE_GROUP_CREATION_EXTENSION_NAME); - skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data->report_data, pPhysicalDeviceGroupCount, + skip |= parameter_validation_vkEnumeratePhysicalDeviceGroupsKHX(my_data, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); if (!skip) { @@ -5097,7 +5097,7 @@ VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHX(VkDevice device, skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkGetDeviceGroupPeerMemoryFeaturesKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME); - skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data->report_data, heapIndex, localDeviceIndex, + skip |= parameter_validation_vkGetDeviceGroupPeerMemoryFeaturesKHX(my_data, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); if (!skip) { @@ -5116,7 +5116,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHX(VkDevice device, uint32_t bi skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkBindBufferMemory2KHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME); - skip |= parameter_validation_vkBindBufferMemory2KHX(my_data->report_data, bindInfoCount, pBindInfos); + skip |= parameter_validation_vkBindBufferMemory2KHX(my_data, bindInfoCount, pBindInfos); if (!skip) { result = my_data->dispatch_table.BindBufferMemory2KHX(device, bindInfoCount, pBindInfos); @@ -5136,7 +5136,7 @@ VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHX(VkDevice device, uint32_t bin skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkBindImageMemory2KHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME); - skip |= parameter_validation_vkBindImageMemory2KHX(my_data->report_data, bindInfoCount, pBindInfos); + skip |= parameter_validation_vkBindImageMemory2KHX(my_data, bindInfoCount, pBindInfos); if (!skip) { result = my_data->dispatch_table.BindImageMemory2KHX(device, bindInfoCount, pBindInfos); @@ -5155,7 +5155,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHX(VkCommandBuffer commandBuffer, ui VK_KHX_DEVICE_GROUP_EXTENSION_NAME); #if 0 // Validation not automatically generated - skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data->report_data, deviceMask); + skip |= parameter_validation_vkCmdSetDeviceMaskKHX(my_data, deviceMask); #endif if (!skip) { @@ -5173,7 +5173,7 @@ GetDeviceGroupPresentCapabilitiesKHX(VkDevice device, VkDeviceGroupPresentCapabi skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkGetDeviceGroupPresentCapabilitiesKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME); - skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data->report_data, pDeviceGroupPresentCapabilities); + skip |= parameter_validation_vkGetDeviceGroupPresentCapabilitiesKHX(my_data, pDeviceGroupPresentCapabilities); if (!skip) { result = my_data->dispatch_table.GetDeviceGroupPresentCapabilitiesKHX(device, pDeviceGroupPresentCapabilities); @@ -5193,7 +5193,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHX(VkDevice dev skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkGetDeviceGroupSurfacePresentModesKHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME); - skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data->report_data, surface, pModes); + skip |= parameter_validation_vkGetDeviceGroupSurfacePresentModesKHX(my_data, surface, pModes); if (!skip) { result = my_data->dispatch_table.GetDeviceGroupSurfacePresentModesKHX(device, surface, pModes); @@ -5212,7 +5212,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHX(VkDevice device, const VkAcq skip |= require_device_extension(my_data, my_data->enables.khx_device_group, "vkAcquireNextImage2KHX", VK_KHX_DEVICE_GROUP_EXTENSION_NAME); - skip |= parameter_validation_vkAcquireNextImage2KHX(my_data->report_data, pAcquireInfo, pImageIndex); + skip |= parameter_validation_vkAcquireNextImage2KHX(my_data, pAcquireInfo, pImageIndex); if (!skip) { result = my_data->dispatch_table.AcquireNextImage2KHX(device, pAcquireInfo, pImageIndex); @@ -5232,7 +5232,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHX(VkCommandBuffer commandBuffer, uin VK_KHX_DEVICE_GROUP_EXTENSION_NAME); #if 0 // Validation not automatically generated - skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data->report_data, baseGroupX, baseGroupY, baseGroupZ, + skip |= parameter_validation_vkCmdDispatchBaseKHX(my_data, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); #endif @@ -5249,7 +5249,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHX(VkPhysicalD auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data->report_data, surface, pRectCount, pRects); + skip |= parameter_validation_vkGetPhysicalDevicePresentRectanglesKHX(my_data, surface, pRectCount, pRects); if (!skip) { result = my_data->dispatch_table.GetPhysicalDevicePresentRectanglesKHX(physicalDevice, surface, pRectCount, pRects); @@ -5271,7 +5271,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHX( skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khx_external_memory_capabilities, "vkGetPhysicalDeviceExternalBufferPropertiesKHX", VK_KHX_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHX(my_data->report_data, pExternalBufferInfo, + skip |= parameter_validation_vkGetPhysicalDeviceExternalBufferPropertiesKHX(my_data, pExternalBufferInfo, pExternalBufferProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceExternalBufferPropertiesKHX(physicalDevice, pExternalBufferInfo, @@ -5291,7 +5291,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHX(VkDevice device, VkDeviceMemory me skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_fd, "vkGetMemoryFdKHX", VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME); - skip |= parameter_validation_vkGetMemoryFdKHX(my_data->report_data, memory, handleType, pFd); + skip |= parameter_validation_vkGetMemoryFdKHX(my_data, memory, handleType, pFd); if (!skip) { result = my_data->dispatch_table.GetMemoryFdKHX(device, memory, handleType, pFd); @@ -5311,7 +5311,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHX(VkDevice device, VkExter skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_fd, "vkGetMemoryFdPropertiesKHX", VK_KHX_EXTERNAL_MEMORY_FD_EXTENSION_NAME); - skip |= parameter_validation_vkGetMemoryFdPropertiesKHX(my_data->report_data, handleType, fd, pMemoryFdProperties); + skip |= parameter_validation_vkGetMemoryFdPropertiesKHX(my_data, handleType, fd, pMemoryFdProperties); if (!skip) { result = my_data->dispatch_table.GetMemoryFdPropertiesKHX(device, handleType, fd, pMemoryFdProperties); @@ -5333,7 +5333,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHX(VkDevice device, VkDevice skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_win32, "vkGetMemoryWin32HandleKHX", VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME); - skip |= parameter_validation_vkGetMemoryWin32HandleKHX(my_data->report_data, memory, handleType, pHandle); + skip |= parameter_validation_vkGetMemoryWin32HandleKHX(my_data, memory, handleType, pHandle); if (!skip) { result = my_data->dispatch_table.GetMemoryWin32HandleKHX(device, memory, handleType, pHandle); @@ -5352,7 +5352,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHX(VkDevice device skip |= require_device_extension(my_data, my_data->enables.khx_external_memory_win32, "vkGetMemoryWin32HandlePropertiesKHX", VK_KHX_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME); - skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHX(my_data->report_data, handleType, handle, + skip |= parameter_validation_vkGetMemoryWin32HandlePropertiesKHX(my_data, handleType, handle, pMemoryWin32HandleProperties); if (!skip) { @@ -5375,7 +5375,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHX( skip |= require_instance_extension(physicalDevice, &InstanceExtensions::khx_external_memory_capabilities, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHX", VK_KHX_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(my_data->report_data, pExternalSemaphoreInfo, + skip |= parameter_validation_vkGetPhysicalDeviceExternalSemaphorePropertiesKHX(my_data, pExternalSemaphoreInfo, pExternalSemaphoreProperties); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceExternalSemaphorePropertiesKHX(physicalDevice, pExternalSemaphoreInfo, @@ -5394,7 +5394,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHX(VkDevice device, const VkImp skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_fd, "vkImportSemaphoreFdKHX", VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME); - skip |= parameter_validation_vkImportSemaphoreFdKHX(my_data->report_data, pImportSemaphoreFdInfo); + skip |= parameter_validation_vkImportSemaphoreFdKHX(my_data, pImportSemaphoreFdInfo); if (!skip) { result = my_data->dispatch_table.ImportSemaphoreFdKHX(device, pImportSemaphoreFdInfo); @@ -5414,7 +5414,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHX(VkDevice device, VkSemaphore se skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_fd, "vkGetSemaphoreFdKHX", VK_KHX_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME); - skip |= parameter_validation_vkGetSemaphoreFdKHX(my_data->report_data, semaphore, handleType, pFd); + skip |= parameter_validation_vkGetSemaphoreFdKHX(my_data, semaphore, handleType, pFd); if (!skip) { result = my_data->dispatch_table.GetSemaphoreFdKHX(device, semaphore, handleType, pFd); @@ -5436,7 +5436,7 @@ ImportSemaphoreWin32HandleKHX(VkDevice device, const VkImportSemaphoreWin32Handl skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_win32, "vkImportSemaphoreWin32HandleKHX", VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME); - skip |= parameter_validation_vkImportSemaphoreWin32HandleKHX(my_data->report_data, pImportSemaphoreWin32HandleInfo); + skip |= parameter_validation_vkImportSemaphoreWin32HandleKHX(my_data, pImportSemaphoreWin32HandleInfo); if (!skip) { result = my_data->dispatch_table.ImportSemaphoreWin32HandleKHX(device, pImportSemaphoreWin32HandleInfo); validate_result(my_data->report_data, "vkImportSemaphoreWin32HandleKHX", {}, result); @@ -5452,7 +5452,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHX(VkDevice device, VkSem assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.khx_external_semaphore_win32, "vkGetSemaphoreWin32HandleKHX", VK_KHX_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME); - skip |= parameter_validation_vkGetSemaphoreWin32HandleKHX(my_data->report_data, semaphore, handleType, pHandle); + skip |= parameter_validation_vkGetSemaphoreWin32HandleKHX(my_data, semaphore, handleType, pHandle); if (!skip) { result = my_data->dispatch_table.GetSemaphoreWin32HandleKHX(device, semaphore, handleType, pHandle); validate_result(my_data->report_data, "vkGetSemaphoreWin32HandleKHX", {}, result); @@ -5471,7 +5471,7 @@ VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(VkPhysicalDevice physicalDe bool skip = false; skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_acquire_xlib_display, "vkAcquireXlibDisplayEXT", VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME); - skip |= parameter_validation_vkAcquireXlibDisplayEXT(my_data->report_data, dpy, display); + skip |= parameter_validation_vkAcquireXlibDisplayEXT(my_data, dpy, display); if (!skip) { result = my_data->dispatch_table.AcquireXlibDisplayEXT(physicalDevice, dpy, display); validate_result(my_data->report_data, "vkAcquireXlibDisplayEXT", {}, result); @@ -5487,7 +5487,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(VkPhysicalDevice physica bool skip = false; skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_acquire_xlib_display, "vkGetRandROutputDisplayEXT", VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME); - skip |= parameter_validation_vkGetRandROutputDisplayEXT(my_data->report_data, dpy, rrOutput, pDisplay); + skip |= parameter_validation_vkGetRandROutputDisplayEXT(my_data, dpy, rrOutput, pDisplay); if (!skip) { result = my_data->dispatch_table.GetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); validate_result(my_data->report_data, "vkGetRandROutputDisplayEXT", {}, result); @@ -5507,7 +5507,7 @@ VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(VkDevice device, VkDeb skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectTagEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME); - skip |= parameter_validation_vkDebugMarkerSetObjectTagEXT(my_data->report_data, pTagInfo); + skip |= parameter_validation_vkDebugMarkerSetObjectTagEXT(my_data, pTagInfo); if (!skip) { if (my_data->dispatch_table.DebugMarkerSetObjectTagEXT) { @@ -5530,7 +5530,7 @@ VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(VkDevice device, VkDe skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkDebugMarkerSetObjectNameEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME); - skip |= parameter_validation_vkDebugMarkerSetObjectNameEXT(my_data->report_data, pNameInfo); + skip |= parameter_validation_vkDebugMarkerSetObjectNameEXT(my_data, pNameInfo); if (!skip) { if (my_data->dispatch_table.DebugMarkerSetObjectNameEXT) { @@ -5552,7 +5552,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerBeginEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME); - skip |= parameter_validation_vkCmdDebugMarkerBeginEXT(my_data->report_data, pMarkerInfo); + skip |= parameter_validation_vkCmdDebugMarkerBeginEXT(my_data, pMarkerInfo); if (!skip && my_data->dispatch_table.CmdDebugMarkerBeginEXT) { my_data->dispatch_table.CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); @@ -5567,7 +5567,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer skip |= require_device_extension(my_data, my_data->enables.ext_debug_marker, "vkCmdDebugMarkerInsertEXT", VK_EXT_DEBUG_MARKER_EXTENSION_NAME); - skip |= parameter_validation_vkCmdDebugMarkerInsertEXT(my_data->report_data, pMarkerInfo); + skip |= parameter_validation_vkCmdDebugMarkerInsertEXT(my_data, pMarkerInfo); if (!skip && my_data->dispatch_table.CmdDebugMarkerInsertEXT) { my_data->dispatch_table.CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); @@ -5584,7 +5584,7 @@ VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(VkPhysicalDevice physicalDevice skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_direct_mode_display, "vkReleaseDisplayEXT", VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME); #if 0 // Validation not automatically generated - skip |= parameter_validation_vkReleaseDisplayEXT(my_data->report_data, display); + skip |= parameter_validation_vkReleaseDisplayEXT(my_data, display); #endif if (!skip) { result = my_data->dispatch_table.ReleaseDisplayEXT(physicalDevice, display); @@ -5604,7 +5604,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(VkCommandBuffer commandBuff skip |= require_device_extension(my_data, my_data->enables.ext_discard_rectangles, "vkCmdSetDiscardRectangleEXT", VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME); - skip |= parameter_validation_vkCmdSetDiscardRectangleEXT(my_data->report_data, firstDiscardRectangle, + skip |= parameter_validation_vkCmdSetDiscardRectangleEXT(my_data, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); if (!skip && my_data->dispatch_table.CmdSetDiscardRectangleEXT) { @@ -5625,7 +5625,7 @@ VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(VkDevice device, VkDisplay skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkDisplayPowerControlEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME); - skip |= parameter_validation_vkDisplayPowerControlEXT(my_data->report_data, display, pDisplayPowerInfo); + skip |= parameter_validation_vkDisplayPowerControlEXT(my_data, display, pDisplayPowerInfo); if (!skip) { if (my_data->dispatch_table.DisplayPowerControlEXT) { @@ -5649,7 +5649,7 @@ VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(VkDevice device, const VkD skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkRegisterDeviceEventEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME); - skip |= parameter_validation_vkRegisterDeviceEventEXT(my_data->report_data, pDeviceEventInfo, pAllocator, pFence); + skip |= parameter_validation_vkRegisterDeviceEventEXT(my_data, pDeviceEventInfo, pAllocator, pFence); if (!skip) { if (my_data->dispatch_table.RegisterDeviceEventEXT) { @@ -5674,7 +5674,7 @@ VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(VkDevice device, VkDispla skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkRegisterDisplayEventEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME); - skip |= parameter_validation_vkRegisterDisplayEventEXT(my_data->report_data, display, pDisplayEventInfo, pAllocator, pFence); + skip |= parameter_validation_vkRegisterDisplayEventEXT(my_data, display, pDisplayEventInfo, pAllocator, pFence); if (!skip) { if (my_data->dispatch_table.RegisterDisplayEventEXT) { @@ -5698,7 +5698,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(VkDevice device, VkSwapcha skip |= require_device_extension(my_data, my_data->enables.ext_display_control, "vkGetSwapchainCounterEXT", VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME); - skip |= parameter_validation_vkGetSwapchainCounterEXT(my_data->report_data, swapchain, counter, pCounterValue); + skip |= parameter_validation_vkGetSwapchainCounterEXT(my_data, swapchain, counter, pCounterValue); if (!skip) { if (my_data->dispatch_table.GetSwapchainCounterEXT) { @@ -5722,7 +5722,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.amd_draw_indirect_count, "vkCmdDrawIndirectCountAMD", VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME); - skip |= parameter_validation_vkCmdDrawIndirectCountAMD(my_data->report_data, buffer, offset, countBuffer, countBufferOffset, + skip |= parameter_validation_vkCmdDrawIndirectCountAMD(my_data, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (!skip) { my_data->dispatch_table.CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, @@ -5738,7 +5738,7 @@ VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(VkCommandBuffer comman assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.amd_draw_indirect_count, "vkCmdDrawIndexedIndirectCountAMD", VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME); - skip |= parameter_validation_vkCmdDrawIndexedIndirectCountAMD(my_data->report_data, buffer, offset, countBuffer, + skip |= parameter_validation_vkCmdDrawIndexedIndirectCountAMD(my_data, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); if (!skip) { my_data->dispatch_table.CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, @@ -5756,7 +5756,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysic bool skip = false; skip |= require_instance_extension(physicalDevice, &InstanceExtensions::ext_display_surface_counter, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME); - skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(my_data->report_data, surface, pSurfaceCapabilities); + skip |= parameter_validation_vkGetPhysicalDeviceSurfaceCapabilities2EXT(my_data, surface, pSurfaceCapabilities); if (!skip) { result = my_data->dispatch_table.GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); validate_result(my_data->report_data, "vkGetPhysicalDeviceSurfaceCapabilities2EXT", {}, result); @@ -5774,7 +5774,7 @@ VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(VkCommandBuffer commandBuffe skip |= require_device_extension(my_data, my_data->enables.amd_draw_indirect_count, "vkCmdSetViewportWScalingNV", VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME); #if 0 // Validation not automatically generated - skip |= parameter_validation_vkCmdSetViewportWScalingNV(my_data->report_data, firstViewport, viewportCount, pViewportWScalings); + skip |= parameter_validation_vkCmdSetViewportWScalingNV(my_data, firstViewport, viewportCount, pViewportWScalings); #endif if (!skip) { my_data->dispatch_table.CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); @@ -5797,7 +5797,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME); skip |= parameter_validation_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( - my_data->report_data, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); + my_data, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); if (!skip) { result = my_data->dispatch_table.GetPhysicalDeviceExternalImageFormatPropertiesNV( @@ -5822,7 +5822,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(VkDevice device, VkDeviceM skip |= require_device_extension(my_data, my_data->enables.nv_external_memory_win32, "vkGetMemoryWin32HandleNV", VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME); - skip |= parameter_validation_vkGetMemoryWin32HandleNV(my_data->report_data, memory, handleType, pHandle); + skip |= parameter_validation_vkGetMemoryWin32HandleNV(my_data, memory, handleType, pHandle); if (!skip) { result = my_data->dispatch_table.GetMemoryWin32HandleNV(device, memory, handleType, pHandle); @@ -5841,7 +5841,7 @@ VKAPI_ATTR void VKAPI_CALL CmdProcessCommandsNVX(VkCommandBuffer commandBuffer, assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCmdProcessCommandsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkCmdProcessCommandsNVX(my_data->report_data, pProcessCommandsInfo); + skip |= parameter_validation_vkCmdProcessCommandsNVX(my_data, pProcessCommandsInfo); if (!skip) { my_data->dispatch_table.CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); } @@ -5854,7 +5854,7 @@ VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(VkCommandBuffer command assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCmdReserveSpaceForCommandsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkCmdReserveSpaceForCommandsNVX(my_data->report_data, pReserveSpaceInfo); + skip |= parameter_validation_vkCmdReserveSpaceForCommandsNVX(my_data, pReserveSpaceInfo); if (!skip) { my_data->dispatch_table.CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); } @@ -5870,7 +5870,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(VkDevice device, assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCreateIndirectCommandsLayoutNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkCreateIndirectCommandsLayoutNVX(my_data->report_data, pCreateInfo, pAllocator, + skip |= parameter_validation_vkCreateIndirectCommandsLayoutNVX(my_data, pCreateInfo, pAllocator, pIndirectCommandsLayout); if (!skip) { result = my_data->dispatch_table.CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); @@ -5887,7 +5887,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(VkDevice device, VkI skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyIndirectCommandsLayoutNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); #if 0 // Validation not automatically generated - skip |= parameter_validation_vkDestroyIndirectCommandsLayoutNVX(my_data->report_data, indirectCommandsLayout, pAllocator); + skip |= parameter_validation_vkDestroyIndirectCommandsLayoutNVX(my_data, indirectCommandsLayout, pAllocator); #endif if (!skip) { my_data->dispatch_table.DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); @@ -5902,7 +5902,7 @@ VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(VkDevice device, const VkObj assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkCreateObjectTableNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkCreateObjectTableNVX(my_data->report_data, pCreateInfo, pAllocator, pObjectTable); + skip |= parameter_validation_vkCreateObjectTableNVX(my_data, pCreateInfo, pAllocator, pObjectTable); if (!skip) { result = my_data->dispatch_table.CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); validate_result(my_data->report_data, "vkCreateObjectTableNVX", {}, result); @@ -5918,7 +5918,7 @@ VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(VkDevice device, VkObjectTableN skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkDestroyObjectTableNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); #if 0 // Validation not automatically generated - skip |= parameter_validation_vkDestroyObjectTableNVX(my_data->report_data, objectTable, pAllocator); + skip |= parameter_validation_vkDestroyObjectTableNVX(my_data, objectTable, pAllocator); #endif if (!skip) { my_data->dispatch_table.DestroyObjectTableNVX(device, objectTable, pAllocator); @@ -5934,7 +5934,7 @@ VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(VkDevice device, VkObjectTable assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkRegisterObjectsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkRegisterObjectsNVX(my_data->report_data, objectTable, objectCount, ppObjectTableEntries, + skip |= parameter_validation_vkRegisterObjectsNVX(my_data, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); if (!skip) { result = my_data->dispatch_table.RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); @@ -5951,7 +5951,7 @@ VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(VkDevice device, VkObjectTab assert(my_data != NULL); skip |= require_device_extension(my_data, my_data->enables.nvx_device_generated_commands, "vkUnregisterObjectsNVX", VK_NVX_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME); - skip |= parameter_validation_vkUnregisterObjectsNVX(my_data->report_data, objectTable, objectCount, pObjectEntryTypes, + skip |= parameter_validation_vkUnregisterObjectsNVX(my_data, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); if (!skip) { result = my_data->dispatch_table.UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); @@ -5966,7 +5966,7 @@ VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhy bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(my_data->report_data, pFeatures, pLimits); + skip |= parameter_validation_vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(my_data, pFeatures, pLimits); if (!skip) { my_data->dispatch_table.GetPhysicalDeviceGeneratedCommandsPropertiesNVX(physicalDevice, pFeatures, pLimits); } @@ -5979,7 +5979,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(VkDevice device, bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetPastPresentationTimingGOOGLE(my_data->report_data, swapchain, pPresentationTimingCount, + skip |= parameter_validation_vkGetPastPresentationTimingGOOGLE(my_data, swapchain, pPresentationTimingCount, pPresentationTimings); if (!skip) { result = my_data->dispatch_table.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, @@ -5994,7 +5994,7 @@ VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(VkDevice device, Vk bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkGetRefreshCycleDurationGOOGLE(my_data->report_data, swapchain, pDisplayTimingProperties); + skip |= parameter_validation_vkGetRefreshCycleDurationGOOGLE(my_data, swapchain, pDisplayTimingProperties); if (!skip) { result = my_data->dispatch_table.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); } @@ -6006,7 +6006,7 @@ VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(VkDevice device, uint32_t swapchain bool skip = false; auto my_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map); assert(my_data != NULL); - skip |= parameter_validation_vkSetHdrMetadataEXT(my_data->report_data, swapchainCount, pSwapchains, pMetadata); + skip |= parameter_validation_vkSetHdrMetadataEXT(my_data, swapchainCount, pSwapchains, pMetadata); if (!skip) { my_data->dispatch_table.SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); } diff --git a/scripts/parameter_validation_generator.py b/scripts/parameter_validation_generator.py index 330e532f..52cedd06 100644 --- a/scripts/parameter_validation_generator.py +++ b/scripts/parameter_validation_generator.py @@ -631,21 +631,22 @@ class ParamCheckerOutputGenerator(OutputGenerator): # # Convert a vulkan.h command declaration into a parameter_validation.h definition def getCmdDef(self, cmd): - # # Strip the trailing ';' and split into individual lines lines = cmd.cdecl[:-1].split('\n') # Replace Vulkan prototype lines[0] = 'static bool parameter_validation_' + cmd.name + '(' - # Replace the first argument with debug_report_data, when the first - # argument is a handle (not vkCreateInstance) - reportData = ' debug_report_data*'.ljust(self.genOpts.alignFuncParam) + 'report_data,' - if cmd.name != 'vkCreateInstance': + # Replace the first argument with debug_report_data, when the first argument is a handle (not vkCreateInstance) + if cmd.name == 'vkCreateInstance': + lines.insert(1, ' instance_layer_data*'.ljust(self.genOpts.alignFuncParam) + 'layer_data,') + else: + if cmd.params[0].type in ["VkInstance", "VkPhysicalDevice"]: + reportData = ' instance_layer_data*'.ljust(self.genOpts.alignFuncParam) + 'layer_data,' + else: + reportData = ' layer_data*'.ljust(self.genOpts.alignFuncParam) + 'layer_data,' if len(lines) < 3: # Terminate correctly if single parameter lines[1] = reportData[:-1] + ')' else: lines[1] = reportData - else: - lines.insert(1, reportData) return '\n'.join(lines) # # Generate the code to check for a NULL dereference before calling the @@ -693,15 +694,15 @@ class ParamCheckerOutputGenerator(OutputGenerator): # This is an array with a pointer to a count value if lenValue.ispointer: # When the length parameter is a pointer, there is an extra Boolean parameter in the function call to indicate if it is required - checkExpr.append('skipCall |= validate_struct_type_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, "{sv}", {pf}{ln}, {pf}{vn}, {sv}, {}, {}, {});\n'.format( + checkExpr.append('skipCall |= validate_struct_type_array(layer_data->report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, "{sv}", {pf}{ln}, {pf}{vn}, {sv}, {}, {}, {});\n'.format( funcPrintName, lenPtrRequired, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, sv=stype.value, pf=prefix, **postProcSpec)) # This is an array with an integer count value else: - checkExpr.append('skipCall |= validate_struct_type_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, "{sv}", {pf}{ln}, {pf}{vn}, {sv}, {}, {});\n'.format( + checkExpr.append('skipCall |= validate_struct_type_array(layer_data->report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, "{sv}", {pf}{ln}, {pf}{vn}, {sv}, {}, {});\n'.format( funcPrintName, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, sv=stype.value, pf=prefix, **postProcSpec)) # This is an individual struct else: - checkExpr.append('skipCall |= validate_struct_type(report_data, "{}", {ppp}"{}"{pps}, "{sv}", {}{vn}, {sv}, {});\n'.format( + checkExpr.append('skipCall |= validate_struct_type(layer_data->report_data, "{}", {ppp}"{}"{pps}, "{sv}", {}{vn}, {sv}, {});\n'.format( funcPrintName, valuePrintName, prefix, valueRequired, vn=value.name, sv=stype.value, **postProcSpec)) return checkExpr # @@ -714,7 +715,7 @@ class ParamCheckerOutputGenerator(OutputGenerator): raise('Unsupported parameter validation case: Output handle array elements are not NULL checked') else: # This is an array with an integer count value - checkExpr.append('skipCall |= validate_handle_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {});\n'.format( + checkExpr.append('skipCall |= validate_handle_array(layer_data->report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {});\n'.format( funcPrintName, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, pf=prefix, **postProcSpec)) else: # This is assumed to be an output handle pointer @@ -729,7 +730,7 @@ class ParamCheckerOutputGenerator(OutputGenerator): raise('Unsupported parameter validation case: array of reserved VkFlags') else: allFlags = 'All' + flagBitsName - checkExpr.append('skipCall |= validate_flags_array(report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, "{}", {}, {pf}{}, {pf}{}, {}, {});\n'.format(funcPrintName, lenPrintName, valuePrintName, flagBitsName, allFlags, lenValue.name, value.name, lenValueRequired, valueRequired, pf=prefix, **postProcSpec)) + checkExpr.append('skipCall |= validate_flags_array(layer_data->report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, "{}", {}, {pf}{}, {pf}{}, {}, {});\n'.format(funcPrintName, lenPrintName, valuePrintName, flagBitsName, allFlags, lenValue.name, value.name, lenValueRequired, valueRequired, pf=prefix, **postProcSpec)) return checkExpr # # Generate pNext check string @@ -745,7 +746,7 @@ class ParamCheckerOutputGenerator(OutputGenerator): extStructCount = 'ARRAY_SIZE(allowedStructs)' extStructVar = 'allowedStructs' extStructNames = '"' + ', '.join(structs) + '"' - checkExpr.append('skipCall |= validate_struct_pnext(report_data, "{}", {ppp}"{}"{pps}, {}, {}{}, {}, {}, GeneratedHeaderVersion);\n'.format( + checkExpr.append('skipCall |= validate_struct_pnext(layer_data->report_data, "{}", {ppp}"{}"{pps}, {}, {}{}, {}, {}, GeneratedHeaderVersion);\n'.format( funcPrintName, valuePrintName, extStructNames, prefix, value.name, extStructCount, extStructVar, **postProcSpec)) return checkExpr # @@ -758,7 +759,7 @@ class ParamCheckerOutputGenerator(OutputGenerator): # If count and array parameters are optional, there will be no validation if valueRequired == 'true' or lenPtrRequired == 'true' or lenValueRequired == 'true': # When the length parameter is a pointer, there is an extra Boolean parameter in the function call to indicate if it is required - checkExpr.append('skipCall |= validate_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {}, {});\n'.format( + checkExpr.append('skipCall |= validate_array(layer_data->report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {}, {});\n'.format( funcPrintName, lenPtrRequired, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, pf=prefix, **postProcSpec)) # This is an array with an integer count value else: @@ -766,7 +767,7 @@ class ParamCheckerOutputGenerator(OutputGenerator): if valueRequired == 'true' or lenValueRequired == 'true': # Arrays of strings receive special processing validationFuncName = 'validate_array' if value.type != 'char' else 'validate_string_array' - checkExpr.append('skipCall |= {}(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {});\n'.format( + checkExpr.append('skipCall |= {}(layer_data->report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {});\n'.format( validationFuncName, funcPrintName, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, pf=prefix, **postProcSpec)) if checkExpr: if lenValue and ('->' in lenValue.name): @@ -776,9 +777,9 @@ class ParamCheckerOutputGenerator(OutputGenerator): elif not value.isoptional: # Function pointers need a reinterpret_cast to void* if value.type[:4] == 'PFN_': - checkExpr.append('skipCall |= validate_required_pointer(report_data, "{}", {ppp}"{}"{pps}, reinterpret_cast({}{}));\n'.format(funcPrintName, valuePrintName, prefix, value.name, **postProcSpec)) + checkExpr.append('skipCall |= validate_required_pointer(layer_data->report_data, "{}", {ppp}"{}"{pps}, reinterpret_cast({}{}));\n'.format(funcPrintName, valuePrintName, prefix, value.name, **postProcSpec)) else: - checkExpr.append('skipCall |= validate_required_pointer(report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcPrintName, valuePrintName, prefix, value.name, **postProcSpec)) + checkExpr.append('skipCall |= validate_required_pointer(layer_data->report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcPrintName, valuePrintName, prefix, value.name, **postProcSpec)) return checkExpr # # Process struct member validation code, performing name suibstitution if required @@ -937,10 +938,10 @@ class ParamCheckerOutputGenerator(OutputGenerator): elif value.type in self.flags and value.isconst: usedLines += self.makeFlagsArrayCheck(valuePrefix, value, lenParam, req, cvReq, funcName, lenDisplayName, valueDisplayName, postProcSpec) elif value.isbool and value.isconst: - usedLines.append('skipCall |= validate_bool32_array(report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, {pf}{}, {pf}{}, {}, {});\n'.format(funcName, lenDisplayName, valueDisplayName, lenParam.name, value.name, cvReq, req, pf=valuePrefix, **postProcSpec)) + usedLines.append('skipCall |= validate_bool32_array(layer_data->report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, {pf}{}, {pf}{}, {}, {});\n'.format(funcName, lenDisplayName, valueDisplayName, lenParam.name, value.name, cvReq, req, pf=valuePrefix, **postProcSpec)) elif value.israngedenum and value.isconst: enumRange = self.enumRanges[value.type] - usedLines.append('skipCall |= validate_ranged_enum_array(report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, "{}", {}, {}, {pf}{}, {pf}{}, {}, {});\n'.format(funcName, lenDisplayName, valueDisplayName, value.type, enumRange[0], enumRange[1], lenParam.name, value.name, cvReq, req, pf=valuePrefix, **postProcSpec)) + usedLines.append('skipCall |= validate_ranged_enum_array(layer_data->report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, "{}", {}, {}, {pf}{}, {pf}{}, {}, {});\n'.format(funcName, lenDisplayName, valueDisplayName, value.type, enumRange[0], enumRange[1], lenParam.name, value.name, cvReq, req, pf=valuePrefix, **postProcSpec)) elif value.name == 'pNext': # We need to ignore VkDeviceCreateInfo and VkInstanceCreateInfo, as the loader manipulates them in a way that is not documented in vk.xml if not structTypeName in ['VkDeviceCreateInfo', 'VkInstanceCreateInfo']: @@ -963,30 +964,30 @@ class ParamCheckerOutputGenerator(OutputGenerator): else: if value.type in self.structTypes: stype = self.structTypes[value.type] - usedLines.append('skipCall |= validate_struct_type(report_data, "{}", {ppp}"{}"{pps}, "{sv}", &({}{vn}), {sv}, false);\n'.format( + usedLines.append('skipCall |= validate_struct_type(layer_data->report_data, "{}", {ppp}"{}"{pps}, "{sv}", &({}{vn}), {sv}, false);\n'.format( funcName, valueDisplayName, valuePrefix, vn=value.name, sv=stype.value, **postProcSpec)) elif value.type in self.handleTypes: if not self.isHandleOptional(value, None): - usedLines.append('skipCall |= validate_required_handle(report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec)) + usedLines.append('skipCall |= validate_required_handle(layer_data->report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec)) elif value.type in self.flags: flagBitsName = value.type.replace('Flags', 'FlagBits') if not flagBitsName in self.flagBits: - usedLines.append('skipCall |= validate_reserved_flags(report_data, "{}", {ppp}"{}"{pps}, {pf}{});\n'.format(funcName, valueDisplayName, value.name, pf=valuePrefix, **postProcSpec)) + usedLines.append('skipCall |= validate_reserved_flags(layer_data->report_data, "{}", {ppp}"{}"{pps}, {pf}{});\n'.format(funcName, valueDisplayName, value.name, pf=valuePrefix, **postProcSpec)) else: flagsRequired = 'false' if value.isoptional else 'true' allFlagsName = 'All' + flagBitsName - usedLines.append('skipCall |= validate_flags(report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {}, false);\n'.format(funcName, valueDisplayName, flagBitsName, allFlagsName, value.name, flagsRequired, pf=valuePrefix, **postProcSpec)) + usedLines.append('skipCall |= validate_flags(layer_data->report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {}, false);\n'.format(funcName, valueDisplayName, flagBitsName, allFlagsName, value.name, flagsRequired, pf=valuePrefix, **postProcSpec)) elif value.type in self.flagBits: flagsRequired = 'false' if value.isoptional else 'true' allFlagsName = 'All' + value.type - usedLines.append('skipCall |= validate_flags(report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {}, true);\n'.format(funcName, valueDisplayName, value.type, allFlagsName, value.name, flagsRequired, pf=valuePrefix, **postProcSpec)) + usedLines.append('skipCall |= validate_flags(layer_data->report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {}, true);\n'.format(funcName, valueDisplayName, value.type, allFlagsName, value.name, flagsRequired, pf=valuePrefix, **postProcSpec)) elif value.isbool: - usedLines.append('skipCall |= validate_bool32(report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec)) + usedLines.append('skipCall |= validate_bool32(layer_data->report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec)) elif value.israngedenum: enumRange = self.enumRanges[value.type] if value.type == "VkObjectEntryTypeNVX": garbage = 2 - usedLines.append('skipCall |= validate_ranged_enum(report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {}, {}{});\n'.format(funcName, valueDisplayName, value.type, enumRange[0], enumRange[1], valuePrefix, value.name, **postProcSpec)) + usedLines.append('skipCall |= validate_ranged_enum(layer_data->report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {}, {}{});\n'.format(funcName, valueDisplayName, value.type, enumRange[0], enumRange[1], valuePrefix, value.name, **postProcSpec)) # # If this is a struct, see if it contains members that need to be checked if value.type in self.validatedStructs: @@ -1022,8 +1023,6 @@ class ParamCheckerOutputGenerator(OutputGenerator): for command in self.commands: # Skip first parameter if it is a dispatch handle (everything except vkCreateInstance) startIndex = 0 if command.name == 'vkCreateInstance' else 1 - if command.name == 'vkCmdDebugMarkerEndEXT': - stop = 'here' lines, unused = self.genFuncBody(command.name, command.params[startIndex:], '', '', None) if self.required_extensions: def_line = 'std::vector required_extensions = {'