Lines Matching refs:dev_data
312 static bool validate_image_usage_flags(layer_data *dev_data, VkImage image, VkFlags desired, VkBool32 strict,
315 auto const image_node = dev_data->imageMap.find(image);
316 if (image_node != dev_data->imageMap.end()) {
317 skipCall = validate_usage_flags(dev_data, image_node->second.createInfo.usage, desired, strict, (uint64_t)image,
326 static bool validate_buffer_usage_flags(layer_data *dev_data, VkBuffer buffer, VkFlags desired, VkBool32 strict,
329 auto const buffer_node = dev_data->bufferMap.find(buffer);
330 if (buffer_node != dev_data->bufferMap.end()) {
331 skipCall = validate_usage_flags(dev_data, buffer_node->second.createInfo.usage, desired, strict, (uint64_t)buffer,
339 static DEVICE_MEM_INFO *get_mem_obj_info(layer_data *dev_data, const VkDeviceMemory mem) {
340 auto item = dev_data->memObjMap.find(mem);
341 if (item != dev_data->memObjMap.end()) {
365 static bool validate_memory_is_valid(layer_data *dev_data, VkDeviceMemory mem, const char *functionName,
368 auto const image_node = dev_data->imageMap.find(image);
369 if (image_node != dev_data->imageMap.end() && !image_node->second.valid) {
370 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
376 DEVICE_MEM_INFO *pMemObj = get_mem_obj_info(dev_data, mem);
378 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
387 static void set_memory_valid(layer_data *dev_data, VkDeviceMemory mem, bool valid, VkImage image = VK_NULL_HANDLE) {
389 auto image_node = dev_data
390 if (image_node != dev_data->imageMap.end()) {
394 DEVICE_MEM_INFO *pMemObj = get_mem_obj_info(dev_data, mem);
403 static bool update_cmd_buf_and_mem_references(layer_data *dev_data, const VkCommandBuffer cb, const VkDeviceMemory mem,
411 DEVICE_MEM_INFO *pMemInfo = get_mem_obj_info(dev_data, mem);
415 GLOBAL_CB_NODE *pCBNode = getCBNode(dev_data, cb);
425 static void clear_cmd_buf_and_mem_references(layer_data *dev_data, GLOBAL_CB_NODE *pCBNode) {
429 DEVICE_MEM_INFO *pInfo = get_mem_obj_info(dev_data, mem);
440 static void clear_cmd_buf_and_mem_references(layer_data *dev_data, const VkCommandBuffer cb) {
441 clear_cmd_buf_and_mem_references(dev_data, getCBNode(dev_data, cb));
445 static bool reportMemReferencesAndCleanUp(layer_data *dev_data, DEVICE_MEM_INFO *pMemObjInfo) {
451 skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
460 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
470 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, obj.type, obj.handle, __LINE__,
493 static bool freeMemObjInfo(layer_data *dev_data, void *object, VkDeviceMemory mem, bool internal) {
496 DEVICE_MEM_INFO *pInfo = get_mem_obj_info(dev_data, mem);
500 skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
515 if (!dev_data->globalInFlightCmdBuffers.count(cb)) {
516 clear_cmd_buf_and_mem_references(dev_data, cb);
522 skipCall |= reportMemReferencesAndCleanUp(dev_data, pInfo);
525 skipCall |= deleteMemObjInfo(dev_data, object, mem);
548 static bool clear_object_binding(layer_data *dev_data, uint64_t handle, VkDebugReportObjectTypeEXT type) {
551 VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
553 DEVICE_MEM_INFO *pMemObjInfo = get_mem_obj_info(dev_data, *pMemBinding);
561 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT,
576 static bool set_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle,
582 skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_MEM_OBJ,
585 VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
587 DEVICE_MEM_INFO *pMemInfo = get_mem_obj_info(dev_data, mem);
589 DEVICE_MEM_INFO *pPrevBinding = get_mem_obj_info(dev_data, *pMemBinding);
591 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
601 auto const image_node = dev_data->imageMap.find(VkImage(handle));
602 if (image_node != dev_data->imageMap.end()) {
622 static bool set_sparse_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle,
627 skipCall = clear_object_binding(dev_data, handle, type);
629 VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
631 DEVICE_MEM_INFO *pInfo = get_mem_obj_info(dev_data, mem);
642 static bool get_mem_binding_from_object(layer_data *dev_data, const uint64_t handle,
646 VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
650 skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT,
658 static void print_mem_list(layer_data *dev_data) {
662 if (!(dev_data->report_data->active_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)) {
667 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__,
669 dev_data->memObjMap.size());
670 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__,
673 if (dev_data->memObjMap.size() <= 0)
676 for (auto ii = dev_data->memObjMap.begin(); ii != dev_data->memObjMap.end(); ++ii) {
679 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
681 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
683 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
688 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
691 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
695 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
700 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
705 dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
711 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
2024 static bool validate_draw_state_flags(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const PIPELINE_NODE *pPipe, bool indexedDraw) {
2026 result = validate_status(dev_data, pCB, CBSTATUS_VIEWPORT_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, DRAWSTATE_VIEWPORT_NOT_BOUND,
2028 result |= validate_status(dev_data, pCB, CBSTATUS_SCISSOR_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT, DRAWSTATE_SCISSOR_NOT_BOUND,
2033 result |= validate_status(dev_data, pCB, CBSTATUS_LINE_WIDTH_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2038 result |= validate_status(dev_data, pCB, CBSTATUS_DEPTH_BIAS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2042 result |= validate_status(dev_data, pCB, CBSTATUS_BLEND_CONSTANTS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2047 result |= validate_status(dev_data, pCB, CBSTATUS_DEPTH_BOUNDS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2052 result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_READ_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2054 result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_WRITE_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2056 result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_REFERENCE_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2060 result |= validate_status(dev_data, pCB, CBSTATUS_INDEX_BUFFER_BOUND, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2642 layer_data *dev_data, GLOBAL_CB_NODE *pCB,
2653 result |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
2665 static void update_shader_storage_images_and_buffers(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
3392 void SetLayout(const layer_data *dev_data, GLOBAL_CB_NODE *pCB, VkImageView imageView, const VkImageLayout &layout) {
3393 auto image_view_data = dev_data->imageViewMap.find(imageView);
3394 assert(image_view_data != dev_data->imageViewMap.end());
3432 static void freeDescriptorSet(layer_data *dev_data, cvdescriptorset::DescriptorSet *descriptor_set) {
3433 dev_data->setMap.erase(descriptor_set->GetSet());
3496 static bool report_error_no_cb_begin(const layer_data *dev_data, const VkCommandBuffer cb, const char *caller_name) {
3497 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3502 bool validateCmdsInCmdBuffer(const layer_data *dev_data, const GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd_type) {
3508 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
3512 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
3622 static void resetCB(layer_data *dev_data, const VkCommandBuffer cb) {
3623 GLOBAL_CB_NODE *pCB = dev_data->commandBufferMap[cb];
3671 dev_data->globalInFlightCmdBuffers.erase(secondary_cb);
3676 clear_cmd_buf_and_mem_references(dev_data, pCB);
3682 auto fbNode = getFramebuffer(dev_data, framebuffer);
3877 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
3878 dev_data->device_extensions.wsi_enabled = false;
3880 VkLayerDispatchTable *pDisp = dev_data->device_dispatch_table;
3890 dev_data->device_extensions.wsi_enabled = true;
3952 layer_data *dev_data = get_my_data_ptr(key, layer_data_map);
3955 deletePipelines(dev_data);
3956 deleteRenderPasses(dev_data);
3957 deleteCommandBuffers(dev_data);
3959 deletePools(dev_data);
3961 assert(dev_data->setMap.empty());
3962 for (auto del_layout : dev_data->descriptorSetLayoutMap) {
3965 dev_data->descriptorSetLayoutMap.clear();
3966 dev_data->imageViewMap.clear();
3967 dev_data->imageMap.clear();
3968 dev_data->imageSubresourceMap.clear();
3969 dev_data->imageLayoutMap.clear();
3970 dev_data->bufferViewMap.clear();
3971 dev_data->bufferMap.clear();
3973 dev_data->queueMap.clear();
3978 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
3980 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
3982 print_mem_list(dev_data);
3983 printCBList(dev_data);
3986 if (!dev_data->memObjMap.empty()) {
3987 for (auto ii = dev_data->memObjMap.begin(); ii != dev_data->memObjMap.end(); ++ii) {
3992 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
4006 VkLayerDispatchTable *pDisp = dev_data->device_dispatch_table;
4011 dev_data->device_dispatch_table->DestroyDevice(device, pAllocator);
4013 delete dev_data->device_dispatch_table;
4022 static bool ValidateCmdBufImageLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
4026 if (!FindLayout(dev_data, cb_image_data.first, imageLayout)) {
4028 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4037 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4047 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4055 SetLayout(dev_data, cb_image_data.first, cb_image_data.second.layout);
4138 static inline void removeInFlightCmdBuffer(layer_data *dev_data, VkCommandBuffer cmd_buffer) {
4140 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmd_buffer);
4143 dev_data->globalInFlightCmdBuffers.erase(cmd_buffer);
4251 static void updateTrackedCommandBuffers(layer_data *dev_data, VkQueue queue, VkQueue other_queue, VkFence fence) {
4255 auto queue_data = dev_data->queueMap.find(queue);
4256 auto other_queue_data = dev_data->queueMap.find(other_queue);
4257 if (queue_data == dev_data->queueMap.end() || other_queue_data == dev_data->queueMap.end()) {
4262 auto fence_node = dev_data->fenceMap.find(fenceInner);
4263 if (fence_node != dev_data->fenceMap.end()) {
4268 auto fence_data = dev_data->fenceMap.find(fence);
4269 if (fence_data == dev_data->fenceMap.end()) {
4366 static bool validateCommandBufferSimultaneousUse(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
4368 if (dev_data->globalInFlightCmdBuffers.count(pCB->commandBuffer) &&
4371 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4379 static bool validateCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
4383 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4400 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4413 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4426 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4439 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4448 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4457 static bool validatePrimaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
4459 bool skipCall = validateAndIncrementResources(dev_data, pCB);
4462 skipCall |= validateAndIncrementResources(dev_data, dev_data->commandBufferMap[secondaryCmdBuffer]);
4463 GLOBAL_CB_NODE *pSubCB = getCBNode(dev_data, secondaryCmdBuffer);
4466 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4477 skipCall |= validateCommandBufferState(dev_data, pCB);
4480 skipCall |= validateCommandBufferSimultaneousUse(dev_data, pCB);
4487 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
4492 if ((submitCount != 0) && dev_data->fenceMap[fence].in_use.load()) {
4493 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
4497 if (!dev_data->fenceMap[fence].needsSignaled) {
4498 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
4505 print_mem_list(dev_data);
4506 printCBList(dev_data);
4508 trackCommandBuffers(dev_data, queue, submitCount, pSubmits, fence);
4517 if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) {
4518 if (dev_data->semaphoreMap[semaphore].signaled) {
4519 dev_data->semaphoreMap[semaphore].signaled = false;
4522 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
4527 const VkQueue &other_queue = dev_data->semaphoreMap[semaphore].queue;
4529 updateTrackedCommandBuffers(dev_data, queue, other_queue, fence);
4536 if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) {
4538 if (dev_data->semaphoreMap[semaphore].signaled) {
4540 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
4545 reinterpret_cast<uint64_t &>(dev_data->semaphoreMap[semaphore].queue));
4547 dev_data->semaphoreMap[semaphore].signaled = true;
4548 dev_data->semaphoreMap[semaphore].queue = queue;
4553 auto pCBNode = getCBNode(dev_data, submit->pCommandBuffers[i]);
4554 skipCall |= ValidateCmdBufImageLayouts(dev_data, pCBNode);
4560 skipCall |= validatePrimaryCommandBufferState(dev_data, pCBNode);
4574 markCommandBuffersInFlight(dev_data, queue, submitCount, pSubmits, fence);
4577 result = dev_data->device_dispatch_table->QueueSubmit(queue, submitCount, pSubmits, fence);
4681 static void initializeAndTrackMemory(layer_data *dev_data, VkDeviceMemory mem, VkDeviceSize size, void **ppData) {
4682 auto mem_element = dev_data->memObjMap.find(mem);
4683 if (mem_element != dev_data->memObjMap.end()) {
4686 if (dev_data->phys_dev_mem_props.memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) {
4730 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4741 VkResult result = dev_data->device_dispatch_table->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
4747 skip_call |= decrementResources(dev_data, fenceCount, pFences);
4760 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4770 result = dev_data->device_dispatch_table->GetFenceStatus(device, fence);
4774 skipCall |= decrementResources(dev_data, 1, &fence);
4784 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4785 dev_data->device_dispatch_table->GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
4789 auto result = dev_data->queues.emplace(*pQueue);
4791 QUEUE_NODE *pQNode = &dev_data->queueMap[*pQueue];
4797 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
4799 skip_call |= decrementResources(dev_data, queue);
4802 VkResult result = dev_data->device_dispatch_table->QueueWaitIdle(queue);
4808 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4810 for (auto queue : dev_data->queues) {
4811 skip_call |= decrementResources(dev_data, queue);
4813 dev_data->globalInFlightCmdBuffers.clear();
4817 VkResult result = dev_data->device_dispatch_table->DeviceWaitIdle(device);
4822 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4825 auto fence_pair = dev_data->fenceMap.find(fence);
4826 if (fence_pair != dev_data->fenceMap.end()) {
4828 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
4832 dev_data->fenceMap.erase(fence_pair);
4837 dev_data->device_dispatch_table->DestroyFence(device, fence, pAllocator);
4842 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4843 dev_data->device_dispatch_table->DestroySemaphore(device, semaphore, pAllocator);
4845 auto item = dev_data->semaphoreMap.find(semaphore);
4846 if (item != dev_data->semaphoreMap.end()) {
4848 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
4852 dev_data->semaphoreMap.erase(semaphore);
4858 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4861 auto event_data = dev_data->eventMap.find(event);
4862 if (event_data != dev_data->eventMap.end()) {
4865 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
4869 dev_data->eventMap.erase(event_data);
4873 dev_data->device_dispatch_table->DestroyEvent(device, event, pAllocator);
4887 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4890 for (auto cmdBuffer : dev_data->globalInFlightCmdBuffers) {
4891 auto pCB = getCBNode(dev_data, cmdBuffer);
4900 auto queryToStateElement = dev_data->queryToStateMap.find(query);
4901 if (queryToStateElement != dev_data->queryToStateMap.end()) {
4903 if (queryElement != queriesInFlight.end() && queryToStateElement != dev_data->queryToStateMap.end() &&
4906 auto pCB = getCBNode(dev_data, cmdBuffer);
4909 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
4915 dev_data->eventMap[event].needsSignaled = true;
4920 } else if (queryElement != queriesInFlight.end() && queryToStateElement != dev_data
4925 auto pCB = getCBNode(dev_data, cmdBuffer);
4929 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
4935 } else if (queryToStateElement != dev_data->queryToStateMap.end() && !queryToStateElement->second) {
4936 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
4941 } else if (queryToStateElement == dev_data->queryToStateMap.end()) {
4942 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
4953 return dev_data->device_dispatch_table->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride,
4974 static bool print_memory_range_error(layer_data *dev_data, const uint64_t object_handle, const uint64_t other_handle,
4977 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, 0,
4981 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, object_type, object_handle, 0,
4987 static bool validate_memory_range(layer_data *dev_data, const vector<MEMORY_RANGE> &ranges, const MEMORY_RANGE &new_range,
4992 if ((range.end & ~(dev_data->phys_dev_properties.properties.limits.bufferImageGranularity - 1)) <
4993 (new_range.start & ~(dev_data->phys_dev_properties.properties.limits.bufferImageGranularity - 1)))
4995 if ((range.start & ~(dev_data->phys_dev_properties.properties.limits.bufferImageGranularity - 1)) >
4996 (new_range.end & ~(dev_data->phys_dev_properties.properties.limits.bufferImageGranularity - 1)))
4998 skip_call |= print_memory_range_error(dev_data, new_range.handle, range.handle, object_type);
5025 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5028 if (!validateIdleBuffer(dev_data, buffer) && !skipCall) {
5030 dev_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
5034 const auto &bufferEntry = dev_data->bufferMap.find(buffer);
5035 if (bufferEntry != dev_data->bufferMap.end()) {
5036 const auto &memEntry = dev_data->memObjMap.find(bufferEntry->second.mem);
5037 if (memEntry != dev_data->memObjMap.end()) {
5040 clear_object_binding(dev_data, reinterpret_cast<uint64_t &>(buffer), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
5041 dev_data->bufferMap.erase(bufferEntry);
5047 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5048 dev_data->device_dispatch_table->DestroyBufferView(device, bufferView, pAllocator);
5050 auto item = dev_data->bufferViewMap.find(bufferView);
5051 if (item != dev_data->bufferViewMap.end()) {
5052 dev_data->bufferViewMap.erase(item);
5057 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5060 dev_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
5064 const auto &imageEntry = dev_data->imageMap.find(image);
5065 if (imageEntry != dev_data->imageMap.end()) {
5067 auto memEntry = dev_data->memObjMap.find(imageEntry->second.mem);
5068 if (memEntry != dev_data->memObjMap.end()) {
5070 clear_object_binding(dev_data, reinterpret_cast<uint64_t &>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
5074 dev_data->imageMap.erase(imageEntry);
5076 const auto& subEntry = dev_data->imageSubresourceMap.find(image);
5077 if (subEntry != dev_data->imageSubresourceMap.end()) {
5079 dev_data->imageLayoutMap.erase(pair);
5081 dev_data->imageSubresourceMap.erase(subEntry);
5087 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5093 set_mem_binding(dev_data, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory");
5094 auto buffer_node = dev_data->bufferMap.find(buffer);
5095 if (buffer_node != dev_data->bufferMap.end()) {
5098 dev_data->device_dispatch_table->GetBufferMemoryRequirements(device, buffer, &memRequirements);
5101 const auto &memEntry = dev_data->memObjMap.find(mem);
5102 if (memEntry != dev_data->memObjMap.end()) {
5106 validate_memory_range(dev_data, memEntry->second.imageRanges, range, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
5112 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0,
5120 VkBufferUsageFlags usage = dev_data->bufferMap[buffer].createInfo.usage;
5122 if (vk_safe_modulo(memoryOffset, dev_data->phys_dev_properties.properties.limits.minTexelBufferOffsetAlignment) != 0) {
5124 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
5128 memoryOffset, dev_data->phys_dev_properties.properties.limits.minTexelBufferOffsetAlignment);
5132 if (vk_safe_modulo(memoryOffset, dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment) !=
5135 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
5139 memoryOffset, dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment);
5143 if (vk_safe_modulo(memoryOffset, dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment) !=
5146 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
5150 memoryOffset, dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment);
5154 print_mem_list(dev_data);
5157 result = dev_data->device_dispatch_table->BindBufferMemory(device, buffer, mem, memoryOffset);
5232 static bool checkAndClearCommandBufferInFlight(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const char *action) {
5234 if (dev_data->globalInFlightCmdBuffers.count(cb_node->commandBuffer)) {
5237 (dev_data->globalInFlightCmdBuffers.count(cb_node->primaryCommandBuffer))) {
5239 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
5244 dev_data->globalInFlightCmdBuffers.erase(cb_node->commandBuffer);
5250 static bool checkAndClearCommandBuffersInFlight(layer_data *dev_data, const VkCommandPool commandPool, const char *action) {
5252 auto pool_data = dev_data->commandPoolMap.find(commandPool);
5253 if (pool_data != dev_data->commandPoolMap.end()) {
5255 if (dev_data->globalInFlightCmdBuffers.count(cmd_buffer)) {
5256 skip_call |= checkAndClearCommandBufferInFlight(dev_data, getCBNode(dev_data, cmd_buffer), action);
5265 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5270 auto cb_pair = dev_data->commandBufferMap.find(pCommandBuffers[i]);
5271 skip_call |= checkAndClearCommandBufferInFlight(dev_data, cb_pair->second, "free");
5273 if (cb_pair != dev_data->commandBufferMap.end()) {
5275 resetCB(dev_data, (*cb_pair).second->commandBuffer);
5277 dev_data->commandBufferMap.erase(cb_pair);
5281 dev_data->commandPoolMap[commandPool].commandBuffers.remove(pCommandBuffers[i]);
5283 printCBList(dev_data);
5287 dev_data->device_dispatch_table->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
5293 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5295 VkResult result = dev_data->device_dispatch_table->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
5299 dev_data->commandPoolMap[*pCommandPool].createFlags = pCreateInfo->flags;
5300 dev_data->commandPoolMap[*pCommandPool].queueFamilyIndex = pCreateInfo->queueFamilyIndex;
5308 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5309 VkResult result = dev_data->device_dispatch_table->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
5312 dev_data->queryPoolMap[*pQueryPool].createInfo = *pCreateInfo;
5320 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5324 VkBool32 result = checkAndClearCommandBuffersInFlight(dev_data, commandPool, "destroy command pool with");
5326 auto pool_it = dev_data->commandPoolMap.find(commandPool);
5327 if (pool_it != dev_data->commandPoolMap.end()) {
5329 clear_cmd_buf_and_mem_references(dev_data, cb);
5330 auto del_cb = dev_data->commandBufferMap.find(cb);
5332 dev_data->commandBufferMap.erase(del_cb); // Remove this command buffer
5335 dev_data->commandPoolMap.erase(commandPool);
5343 dev_data->device_dispatch_table->DestroyCommandPool(device, commandPool, pAllocator);
5348 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5352 if (checkAndClearCommandBuffersInFlight(dev_data, commandPool, "reset command pool with"))
5356 result = dev_data->device_dispatch_table->ResetCommandPool(device, commandPool, flags);
5361 auto it = dev_data->commandPoolMap[commandPool].commandBuffers.begin();
5362 while (it != dev_data->commandPoolMap[commandPool].commandBuffers.end()) {
5363 resetCB(dev_data, (*it));
5371 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5376 auto fence_item = dev_data->fenceMap.find(pFences[i]);
5377 if (fence_item != dev_data->fenceMap.end()) {
5383 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
5391 result = dev_data->device_dispatch_table->ResetFences(device, fenceCount, pFences);
5397 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5399 auto fbNode = dev_data->frameBufferMap.find(framebuffer);
5400 if (fbNode != dev_data->frameBufferMap.end()) {
5402 auto cbNode = dev_data->commandBufferMap.find(cb);
5403 if (cbNode != dev_data->commandBufferMap.end()) {
5410 dev_data->frameBufferMap.erase(fbNode);
5413 dev_data->device_dispatch_table->DestroyFramebuffer(device, framebuffer, pAllocator);
5418 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5419 dev_data->device_dispatch_table->DestroyRenderPass(device, renderPass, pAllocator);
5421 dev_data->renderPassMap.erase(renderPass);
5426 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5428 VkResult result = dev_data->device_dispatch_table->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
5433 dev_data->bufferMap.insert(std::make_pair(*pBuffer, BUFFER_NODE(pCreateInfo)));
5440 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5441 VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pAllocator, pView);
5444 dev_data->bufferViewMap[*pView] = VkBufferViewCreateInfo(*pCreateInfo);
5447 validate_buffer_usage_flags(dev_data, pCreateInfo->buffer,
5456 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5458 VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pAllocator, pImage);
5465 dev_data->imageMap.insert(std::make_pair(*pImage, IMAGE_NODE(pCreateInfo)));
5467 dev_data->imageSubresourceMap[*pImage].push_back(subpair);
5468 dev_data->imageLayoutMap[subpair] = image_node;
5473 static void ResolveRemainingLevelsLayers(layer_data *dev_data, VkImageSubresourceRange *range, VkImage image) {
5476 auto image_node_it = dev_data->imageMap.find(image);
5477 if (image_node_it != dev_data->imageMap.end()) {
5494 static void ResolveRemainingLevelsLayers(layer_data *dev_data, uint32_t *levels, uint32_t *layers, VkImageSubresourceRange range,
5500 auto image_node_it = dev_data->imageMap.find(image);
5501 if (image_node_it != dev_data->imageMap.end()) {
5515 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5519 skipCall |= validate_image_usage_flags(dev_data, pCreateInfo->image,
5526 result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pAllocator, pView);
5532 ResolveRemainingLevelsLayers(dev_data, &localCI.subresourceRange, pCreateInfo->image);
5533 dev_data->imageViewMap[*pView] = localCI;
5541 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5542 VkResult result = dev_data->device_dispatch_table->CreateFence(device, pCreateInfo, pAllocator, pFence);
5545 auto &fence_node = dev_data->fenceMap[*pFence];
5560 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5561 VkResult result = dev_data->device_dispatch_table->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
5567 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5568 dev_data->device_dispatch_table->DestroyPipelineCache(device, pipelineCache, pAllocator);
5573 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5574 VkResult result = dev_data->device_dispatch_table->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
5580 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5581 VkResult result = dev_data->device_dispatch_table->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
5619 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5627 pPipeNode[i]->renderPass = getRenderPass(dev_data, pCreateInfos[i].renderPass);
5628 pPipeNode[i]->pipelineLayout = getPipelineLayout(dev_data, pCreateInfos[i].layout);
5630 skipCall |= verifyPipelineCreateState(dev_data, device, pPipeNode, i);
5635 result = dev_data->device_dispatch_table->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator,
5640 dev_data->pipelineMap[pPipeNode[i]->pipeline] = pPipeNode[i];
5662 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5672 pPipeNode[i]->pipelineLayout = getPipelineLayout(dev_data, pCreateInfos[i].layout);
5676 // skipCall |= verifyPipelineCreateState(dev_data, device, pPipeNode[i]);
5681 result = dev_data->device_dispatch_table->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator,
5686 dev_data->pipelineMap[pPipeNode[i]->pipeline] = pPipeNode[i];
5702 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5703 VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
5706 dev_data->samplerMap[*pSampler] = unique_ptr<SAMPLER_NODE>(new SAMPLER_NODE(pSampler, pCreateInfo));
5714 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5715 VkResult result = dev_data->device_dispatch_table->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
5719 dev_data->descriptorSetLayoutMap[*pSetLayout] =
5720 new cvdescriptorset::DescriptorSetLayout(dev_data->report_data, pCreateInfo, *pSetLayout);
5727 static bool validatePushConstantRange(const layer_data *dev_data, const uint32_t offset, const uint32_t size,
5729 uint32_t const maxPushConstantsSize = dev_data->phys_dev_properties.properties.limits.maxPushConstantsSize;
5737 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5742 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5747 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5755 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5761 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5766 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5773 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5778 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5783 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5793 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5797 skipCall |= validatePushConstantRange(dev_data, pCreateInfo->pPushConstantRanges[i].offset,
5800 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5815 log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
5827 VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
5830 PIPELINE_LAYOUT_NODE &plNode = dev_data->pipelineLayoutMap[*pPipelineLayout];
5835 plNode.setLayouts[i] = getDescriptorSetLayout(dev_data, pCreateInfo->pSetLayouts[i]);
5848 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5849 VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
5852 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
5858 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
5864 dev_data->descriptorPoolMap[*pDescriptorPool] = pNewNode;
5874 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5875 VkResult result = dev_data->device_dispatch_table->ResetDescriptorPool(device, descriptorPool, flags);
5878 clearDescriptorPool(dev_data, device, descriptorPool, flags);
5886 static bool PreCallValidateAllocateDescriptorSets(layer_data *dev_data, DESCRIPTOR_POOL_NODE *pPoolNode, uint32_t count,
5893 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
5915 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
5930 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5938 layout_nodes[i] = getDescriptorSetLayout(dev_data, pAllocateInfo->pSetLayouts[i]);
5940 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT,
5947 DESCRIPTOR_POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocateInfo->descriptorPool);
5950 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
5955 skipCall |= PreCallValidateAllocateDescriptorSets(dev_data, pPoolNode, pAllocateInfo->descriptorSetCount,
5963 VkResult result = dev_data->device_dispatch_table->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
5980 pDescriptorSets[i], layout_nodes[i], &dev_data->bufferMap, &dev_data->memObjMap, &dev_data->bufferViewMap,
5981 &dev_data->samplerMap, &dev_data->imageViewMap, &dev_data->imageMap,
5982 &dev_data->device_extensions.imageToSwapchainMap, &dev_data->device_extensions.swapchainMap);
5986 dev_data->setMap[pDescriptorSets[i]] = pNewNode;
5998 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6002 skipCall |= validateIdleDescriptorSet(dev_data, pDescriptorSets[i], "vkFreeDescriptorSets");
6003 DESCRIPTOR_POOL_NODE *pPoolNode = getPoolNode(dev_data, descriptorPool);
6006 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
6014 VkResult result = dev_data->device_dispatch_table->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
6023 cvdescriptorset::DescriptorSet *pSet = dev_data->setMap[pDescriptorSets[i]]; // getSetNode() without locking
6030 freeDescriptorSet(dev_data, pSet);
6042 static bool PreCallValidateUpdateDescriptorSets(layer_data *dev_data, uint32_t descriptorWriteCount,
6052 return cvdescriptorset::ValidateUpdateDescriptorSets(dev_data->report_data, dev_data->setMap, descriptorWriteCount,
6056 static void PostCallRecordUpdateDescriptorSets(layer_data *dev_data, uint32_t descriptorWriteCount,
6059 cvdescriptorset::PerformUpdateDescriptorSets(dev_data->setMap, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
6067 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6069 bool skip_call = PreCallValidateUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
6073 dev_data->device_dispatch_table->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
6077 PostCallRecordUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
6084 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6085 VkResult result = dev_data->device_dispatch_table->AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
6088 auto const &cp_it = dev_data->commandPoolMap.find(pCreateInfo->commandPool);
6089 if (cp_it != dev_data->commandPoolMap.end()) {
6095 dev_data->commandBufferMap[pCommandBuffer[i]] = pCB;
6096 resetCB(dev_data, pCommandBuffer[i]);
6101 dev_data);
6110 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6113 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6116 if (dev_data->globalInFlightCmdBuffers.count(commandBuffer)) {
6118 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6124 clear_cmd_buf_and_mem_references(dev_data, pCB);
6130 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6138 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6144 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT,
6152 auto framebuffer = getFramebuffer(dev_data, pInfo->framebuffer);
6155 if (!verify_renderpass_compatibility(dev_data, fbRP, pInfo->renderPass, errorString)) {
6158 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6173 dev_data->phys_dev_properties.features.occlusionQueryPrecise == VK_FALSE) &&
6175 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6185 auto renderPass = getRenderPass(dev_data, pInfo->renderPass);
6188 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6200 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6207 if (!(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT & dev_data->commandPoolMap[cmdPool].createFlags)) {
6209 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6216 resetCB(dev_data, commandBuffer);
6227 pCB->activeRenderPass = getRenderPass(dev_data, pCB->beginInfo.pInheritanceInfo->renderPass);
6233 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6241 VkResult result = dev_data->device_dispatch_table->BeginCommandBuffer(commandBuffer, pBeginInfo);
6249 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6251 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6256 skipCall |= insideRenderPass(dev_data, pCB, "vkEndCommandBuffer");
6258 skipCall |= addCmd(dev_data, pCB, CMD_END, "vkEndCommandBuffer()");
6260 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6268 result = dev_data->device_dispatch_table->EndCommandBuffer(commandBuffer);
6274 printCB(dev_data, commandBuffer);
6286 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6288 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6290 if (!(VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT & dev_data->commandPoolMap[cmdPool].createFlags)) {
6291 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6297 skip_call |= checkAndClearCommandBufferInFlight(dev_data, pCB, "reset");
6301 VkResult result = dev_data->device_dispatch_table->ResetCommandBuffer(commandBuffer, flags);
6304 resetCB(dev_data, commandBuffer);
6313 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6315 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6317 skipCall |= addCmd(dev_data, pCB, CMD_BINDPIPELINE, "vkCmdBindPipeline()");
6320 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
6326 PIPELINE_NODE *pPN = getPipeline(dev_data, pipeline);
6332 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
6339 dev_data->device_dispatch_table->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
6345 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6347 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6349 skipCall |= addCmd(dev_data, pCB, CMD_SETVIEWPORTSTATE, "vkCmdSetViewport()");
6356 dev_data->device_dispatch_table->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
6362 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6364 GLOBAL_CB_NODE *pCB = getCBNode(dev_data
6366 skipCall |= addCmd(dev_data, pCB, CMD_SETSCISSORSTATE, "vkCmdSetScissor()");
6373 dev_data->device_dispatch_table->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
6378 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6380 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6382 skip_call |= addCmd(dev_data, pCB, CMD_SETLINEWIDTHSTATE, "vkCmdSetLineWidth()");
6385 PIPELINE_NODE *pPipeTrav = getPipeline(dev_data, pCB->lastBound[VK_PIPELINE_BIND_POINT_GRAPHICS].pipeline);
6387 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0,
6392 skip_call |= verifyLineWidth(dev_data, DRAWSTATE_INVALID_SET, reinterpret_cast<uint64_t &>(commandBuffer), lineWidth);
6397 dev_data->device_dispatch_table->CmdSetLineWidth(commandBuffer, lineWidth);
6403 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6405 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6407 skipCall |= addCmd(dev_data, pCB, CMD_SETDEPTHBIASSTATE, "vkCmdSetDepthBias()");
6412 dev_data->device_dispatch_table->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp,
6418 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6420 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6422 skipCall |= addCmd(dev_data, pCB, CMD_SETBLENDSTATE, "vkCmdSetBlendConstants()");
6427 dev_data->device_dispatch_table->CmdSetBlendConstants(commandBuffer, blendConstants);
6433 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6435 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6437 skipCall |= addCmd(dev_data, pCB, CMD_SETDEPTHBOUNDSSTATE, "vkCmdSetDepthBounds()");
6442 dev_data->device_dispatch_table->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
6448 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6450 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6452 skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILREADMASKSTATE, "vkCmdSetStencilCompareMask()");
6457 dev_data->device_dispatch_table->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
6463 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6465 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6467 skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILWRITEMASKSTATE, "vkCmdSetStencilWriteMask()");
6472 dev_data->device_dispatch_table->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
6478 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6480 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6482 skipCall |= addCmd(dev_data, pCB, CMD_SETSTENCILREFERENCESTATE, "vkCmdSetStencilReference()");
6487 dev_data->device_dispatch_table->CmdSetStencilReference(commandBuffer, faceMask, reference);
6495 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6497 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6510 cvdescriptorset::DescriptorSet *pSet = getSetNode(dev_data, pDescriptorSets[i]);
6516 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
6521 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT,
6529 if (!verify_set_layout_compatibility(dev_data, pSet, layout, i + firstSet, errorString)) {
6530 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6546 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6561 dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment) != 0) {
6563 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6569 dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment);
6575 dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment) != 0) {
6577 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6583 dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment);
6598 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6603 skipCall |= addCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS, "vkCmdBindDescriptorSets()");
6608 !verify_set_layout_compatibility(dev_data, pCB->lastBound[pipelineBindPoint].boundDescriptorSets[i],
6611 dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
6624 !verify_set_layout_compatibility(dev_data, oldFinalBoundSet, layout, lastSetIndex, errorString)) {
6627 log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
6642 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
6650 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDescriptorSets()");
6655 dev_data->device_dispatch_table->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount,
6662 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6667 get_mem_binding_from_object(dev_data, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
6668 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
6669 if (cb_data != dev_data->commandBufferMap.end()) {
6670 std::function<bool()> function = [=]() { return validate_memory_is_valid(dev_data, mem, "vkCmdBindIndexBuffer()"); };
6672 skipCall |= addCmd(dev_data, cb_data->second, CMD_BINDINDEXBUFFER, "vkCmdBindIndexBuffer()");
6686 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6695 dev_data->device_dispatch_table->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
6714 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6717 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
6718 if (cb_data != dev_data->commandBufferMap.end()) {
6721 skipCall |= get_mem_binding_from_object(dev_data, (uint64_t)pBuffers[i], VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
6723 std::function<bool()> function = [=]() { return validate_memory_is_valid(dev_data, mem, "vkCmdBindVertexBuffers()"); };
6726 addCmd(dev_data, cb_data->second, CMD_BINDVERTEXBUFFER, "vkCmdBindVertexBuffer()");
6729 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindVertexBuffer()");
6733 dev_data->device_dispatch_table->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
6737 static bool markStoreImagesAndBuffersAsWritten(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
6741 auto iv_data = dev_data->imageViewMap.find(imageView);
6742 if (iv_data == dev_data->imageViewMap.end())
6747 get_mem_binding_from_object(dev_data, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem);
6749 set_memory_valid(dev_data, mem, true, image);
6756 skip_call |= get_mem_binding_from_object(dev_data, (uint64_t)buffer,
6759 set_memory_valid(dev_data, mem, true);
6770 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6772 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6774 skipCall |= addCmd(dev_data, pCB, CMD_DRAW, "vkCmdDraw()");
6776 skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_GRAPHICS);
6777 skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
6780 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
6782 skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
6786 skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDraw");
6790 dev_data->device_dispatch_table->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
6796 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6799 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6801 skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXED, "vkCmdDrawIndexed()");
6803 skipCall |= validate_and_update_draw_state(dev_data, pCB, true, VK_PIPELINE_BIND_POINT_GRAPHICS);
6804 skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
6806 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
6809 skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
6813 skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexed");
6817 dev_data->device_dispatch_table->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset,
6823 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6829 get_mem_binding_from_object(dev_data, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
6830 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDrawIndirect");
6831 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6833 skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDIRECT, "vkCmdDrawIndirect()");
6835 skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_GRAPHICS);
6836 skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
6838 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
6841 skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
6845 skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndirect");
6849 dev_data->device_dispatch_table->CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
6855 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6860 get_mem_binding_from_object(dev_data, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
6861 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDrawIndexedIndirect");
6862 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6864 skipCall |= addCmd(dev_data, pCB, CMD_DRAWINDEXEDINDIRECT, "vkCmdDrawIndexedIndirect()");
6866 skipCall |= validate_and_update_draw_state(dev_data, pCB, true, VK_PIPELINE_BIND_POINT_GRAPHICS);
6867 skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
6870 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
6873 skipCall |= synchAndPrintDSConfig(dev_data, commandBuffer);
6877 skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexedIndirect");
6881 dev_data->device_dispatch_table->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
6886 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6888 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6890 skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_COMPUTE);
6892 update_shader_storage_images_and_buffers(dev_data, pCB);
6893 skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
6894 skipCall |= addCmd(dev_data, pCB, CMD_DISPATCH, "vkCmdDispatch()");
6895 skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatch");
6899 dev_data->device_dispatch_table->CmdDispatch(commandBuffer, x, y, z);
6905 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6909 get_mem_binding_from_object(dev_data, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
6910 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdDispatchIndirect");
6911 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
6913 skipCall |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_COMPUTE);
6915 update_shader_storage_images_and_buffers(dev_data, pCB);
6916 skipCall |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
6917 skipCall |= addCmd(dev_data, pCB, CMD_DISPATCHINDIRECT, "vkCmdDispatchIndirect()");
6918 skipCall |= insideRenderPass(dev_data, pCB, "vkCmdDispatchIndirect");
6922 dev_data->device_dispatch_table->CmdDispatchIndirect(commandBuffer, buffer, offset);
6928 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
6931 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &src_mem);
6932 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyBuffer");
6933 skipCall |= get_mem_binding_from_object(dev_data, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &dst_mem);
6935 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyBuffer");
6937 skipCall |= validate_buffer_usage_flags(dev_data, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true,
6939 skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
6941 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
6942 if (cb_data != dev_data->commandBufferMap.end()) {
6943 std::function<bool()> function = [=]() { return validate_memory_is_valid(dev_data, src_mem, "vkCmdCopyBuffer()"); };
6946 set_memory_valid(dev_data, dst_mem, true);
6951 skipCall |= addCmd(dev_data, cb_data->second, CMD_COPYBUFFER, "vkCmdCopyBuffer()");
6952 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdCopyBuffer");
6956 dev_data->device_dispatch_table->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
6963 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
6964 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer);
6976 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
6985 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0,
6989 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7002 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
7003 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer);
7014 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
7023 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0,
7027 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7040 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7044 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &src_mem);
7045 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyImage");
7047 skipCall |= get_mem_binding_from_object(dev_data, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &dst_mem);
7048 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyImage");
7049 skipCall |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
7051 skipCall |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
7053 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7054 if (cb_data != dev_data->commandBufferMap.end()) {
7056 return validate_memory_is_valid(dev_data, src_mem, "vkCmdCopyImage()", srcImage);
7060 set_memory_valid(dev_data, dst_mem, true, dstImage);
7065 skipCall |= addCmd(dev_data, cb_data->second, CMD_COPYIMAGE, "vkCmdCopyImage()");
7066 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdCopyImage");
7074 dev_data->device_dispatch_table->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
7082 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7086 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &src_mem);
7087 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdBlitImage");
7089 skipCall |= get_mem_binding_from_object(dev_data, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &dst_mem);
7090 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdBlitImage");
7091 skipCall |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
7093 skipCall |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
7096 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7097 if (cb_data != dev_data->commandBufferMap.end()) {
7099 return validate_memory_is_valid(dev_data, src_mem, "vkCmdBlitImage()", srcImage);
7103 set_memory_valid(dev_data, dst_mem, true, dstImage);
7108 skipCall |= addCmd(dev_data, cb_data->second, CMD_BLITIMAGE, "vkCmdBlitImage()");
7109 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdBlitImage");
7113 dev_data->device_dispatch_table->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
7121 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7124 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &dst_mem);
7125 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyBufferToImage");
7127 skipCall |= get_mem_binding_from_object(dev_data, (uint64_t)srcBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &src_mem);
7128 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyBufferToImage");
7130 skipCall |= validate_buffer_usage_flags(dev_data, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBufferToImage()",
7132 skipCall |= validate_image_usage_flags(dev_data, dstImage, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBufferToImage()",
7134 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7135 if (cb_data != dev_data->commandBufferMap.end()) {
7137 set_memory_valid(dev_data, dst_mem, true, dstImage);
7141 function = [=]() { return validate_memory_is_valid(dev_data, src_mem, "vkCmdCopyBufferToImage()"); };
7144 skipCall |= addCmd(dev_data, cb_data->second, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()");
7145 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdCopyBufferToImage");
7152 dev_data->device_dispatch_table->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount,
7160 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7163 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &src_mem);
7164 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdCopyImageToBuffer");
7166 skipCall |= get_mem_binding_from_object(dev_data
7167 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdCopyImageToBuffer");
7169 skipCall |= validate_image_usage_flags(dev_data, srcImage, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImageToBuffer()",
7171 skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImageToBuffer()",
7174 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7175 if (cb_data != dev_data->commandBufferMap.end()) {
7177 return validate_memory_is_valid(dev_data, src_mem, "vkCmdCopyImageToBuffer()", srcImage);
7181 set_memory_valid(dev_data, dst_mem, true);
7186 skipCall |= addCmd(dev_data, cb_data->second, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()");
7187 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdCopyImageToBuffer");
7194 dev_data->device_dispatch_table->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount,
7201 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7205 get_mem_binding_from_object(dev_data, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
7206 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdUpdateBuffer");
7208 skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdUpdateBuffer()",
7211 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7212 if (cb_data != dev_data->commandBufferMap.end()) {
7214 set_memory_valid(dev_data, mem, true);
7219 skipCall |= addCmd(dev_data, cb_data->second, CMD_UPDATEBUFFER, "vkCmdUpdateBuffer()");
7220 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdCopyUpdateBuffer");
7224 dev_data->device_dispatch_table->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
7230 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7234 get_mem_binding_from_object(dev_data, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
7235 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdFillBuffer");
7237 skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdFillBuffer()",
7240 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7241 if (cb_data != dev_data->commandBufferMap.end()) {
7243 set_memory_valid(dev_data, mem, true);
7248 skipCall |= addCmd(dev_data, cb_data->second, CMD_FILLBUFFER, "vkCmdFillBuffer()");
7249 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdCopyFillBuffer");
7253 dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
7260 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7262 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7264 skipCall |= addCmd(dev_data, pCB, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()");
7273 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
7279 skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdClearAttachments");
7299 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7310 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7323 dev_data->device_dispatch_table->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
7330 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7334 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem);
7335 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdClearColorImage");
7336 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7337 if (cb_data != dev_data->commandBufferMap.end()) {
7339 set_memory_valid(dev_data, mem, true, image);
7344 skipCall |= addCmd(dev_data, cb_data->second, CMD_CLEARCOLORIMAGE, "vkCmdClearColorImage()");
7345 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdClearColorImage");
7349 dev_data->device_dispatch_table->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
7357 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7361 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem);
7362 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdClearDepthStencilImage");
7363 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7364 if (cb_data != dev_data->commandBufferMap.end()) {
7366 set_memory_valid(dev_data, mem, true, image);
7371 skipCall |= addCmd(dev_data, cb_data->second, CMD_CLEARDEPTHSTENCILIMAGE, "vkCmdClearDepthStencilImage()");
7372 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdClearDepthStencilImage");
7376 dev_data->device_dispatch_table->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount,
7384 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7387 skipCall = get_mem_binding_from_object(dev_data, (uint64_t)srcImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &src_mem);
7388 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, src_mem, "vkCmdResolveImage");
7390 skipCall |= get_mem_binding_from_object(dev_data, (uint64_t)dstImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &dst_mem);
7391 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, dst_mem, "vkCmdResolveImage");
7392 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
7393 if (cb_data != dev_data->commandBufferMap.end()) {
7395 return validate_memory_is_valid(dev_data, src_mem, "vkCmdResolveImage()", srcImage);
7399 set_memory_valid(dev_data, dst_mem, true, dstImage);
7404 skipCall |= addCmd(dev_data, cb_data->second, CMD_RESOLVEIMAGE, "vkCmdResolveImage()");
7405 skipCall |= insideRenderPass(dev_data, cb_data->second, "vkCmdResolveImage");
7409 dev_data->device_dispatch_table->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout,
7414 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7415 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7419 auto queue_data = dev_data->queueMap.find(queue);
7420 if (queue_data != dev_data->queueMap.end()) {
7429 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7431 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7433 skipCall |= addCmd(dev_data, pCB, CMD_SETEVENT, "vkCmdSetEvent()");
7434 skipCall |= insideRenderPass(dev_data, pCB, "vkCmdSetEvent");
7445 dev_data->device_dispatch_table->CmdSetEvent(commandBuffer, event, stageMask);
7451 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7453 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7455 skipCall |= addCmd(dev_data
7456 skipCall |= insideRenderPass(dev_data, pCB, "vkCmdResetEvent");
7467 dev_data->device_dispatch_table->CmdResetEvent(commandBuffer, event, stageMask);
7472 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
7473 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer);
7484 ResolveRemainingLevelsLayers(dev_data, &levelCount, &layerCount, mem_barrier->subresourceRange, mem_barrier->image);
7500 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
7631 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
7632 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer);
7635 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7643 auto image_data = dev_data->imageMap.find(mem_barrier->image);
7644 if (image_data != dev_data->imageMap.end()) {
7651 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
7665 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7672 ((src_q_f_index >= dev_data->phys_dev_properties.queue_family_properties.size()) ||
7673 (dst_q_f_index >= dev_data->phys_dev_properties.queue_family_properties.size()))) {
7674 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
7681 dst_q_f_index, dev_data->phys_dev_properties.queue_family_properties.size());
7688 ValidateMaskBitsFromLayouts(dev_data, cmdBuffer, mem_barrier->srcAccessMask, mem_barrier->oldLayout, "Source");
7690 ValidateMaskBitsFromLayouts(dev_data, cmdBuffer, mem_barrier->dstAccessMask, mem_barrier->newLayout, "Dest");
7692 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7697 auto image_data = dev_data->imageMap.find(mem_barrier->image);
7701 if (image_data != dev_data->imageMap.end()) {
7706 } else if (dev_data->device_extensions.wsi_enabled) {
7707 auto imageswap_data = dev_data->device_extensions.imageToSwapchainMap.find(mem_barrier->image);
7708 if (imageswap_data != dev_data->device_extensions.imageToSwapchainMap.end()) {
7709 auto swapchain_data = dev_data->device_extensions.swapchainMap.find(imageswap_data->second);
7710 if (swapchain_data != dev_data->device_extensions.swapchainMap.end()) {
7722 log_msg(dev_data
7732 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7743 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7757 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7765 mem_barrier->srcQueueFamilyIndex >= dev_data->phys_dev_properties.queue_family_properties.size()) ||
7767 mem_barrier->dstQueueFamilyIndex >= dev_data->phys_dev_properties.queue_family_properties.size())) {
7768 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7773 dev_data->phys_dev_properties.queue_family_properties.size());
7776 auto buffer_data = dev_data->bufferMap.find(mem_barrier->buffer);
7777 if (buffer_data != dev_data->bufferMap.end()) {
7783 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7790 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7805 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
7808 auto queue_data = dev_data->queueMap.find(queue);
7809 if (queue_data == dev_data->queueMap.end())
7815 auto global_event_data = dev_data->eventMap.find(event);
7816 if (global_event_data == dev_data->eventMap.end()) {
7817 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
7829 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7846 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7848 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7859 skipCall |= addCmd(dev_data, pCB, CMD_WAITEVENTS, "vkCmdWaitEvents()");
7861 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWaitEvents()");
7870 dev_data->device_dispatch_table->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask,
7881 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7883 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7885 skipCall |= addCmd(dev_data, pCB, CMD_PIPELINEBARRIER, "vkCmdPipelineBarrier()");
7893 dev_data->device_dispatch_table->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
7899 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7900 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7904 auto queue_data = dev_data->queueMap.find(queue);
7905 if (queue_data != dev_data->queueMap.end()) {
7914 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7916 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7923 skipCall |= addCmd(dev_data, pCB, CMD_BEGINQUERY, "vkCmdBeginQuery()");
7927 dev_data->device_dispatch_table->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
7932 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7934 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7939 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7948 skipCall |= addCmd(dev_data, pCB, CMD_ENDQUERY, "VkCmdEndQuery()");
7950 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdEndQuery()");
7955 dev_data->device_dispatch_table->CmdEndQuery(commandBuffer, queryPool, slot);
7961 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7963 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7972 skipCall |= addCmd(dev_data, pCB, CMD_RESETQUERYPOOL, "VkCmdResetQueryPool()");
7974 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetQueryPool()");
7976 skipCall |= insideRenderPass(dev_data, pCB, "vkCmdQueryPool");
7980 dev_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
7985 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(pCB->commandBuffer), layer_data_map);
7986 auto queue_data = dev_data->queueMap.find(queue);
7987 if (queue_data == dev_data->queueMap.end())
7998 auto global_query_data = dev_data->queryToStateMap.find(query);
7999 if (global_query_data != dev_data->queryToStateMap.end()) {
8008 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8021 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8023 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8026 auto cb_data = dev_data->commandBufferMap.find(commandBuffer);
8028 get_mem_binding_from_object(dev_data, (uint64_t)dstBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, &mem);
8029 if (cb_data != dev_data->commandBufferMap.end()) {
8031 set_memory_valid(dev_data, mem, true);
8036 skipCall |= update_cmd_buf_and_mem_references(dev_data, commandBuffer, mem, "vkCmdCopyQueryPoolResults");
8038 skipCall |= validate_buffer_usage_flags(dev_data, dstBuffer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
8046 skipCall |= addCmd(dev_data, pCB, CMD_COPYQUERYPOOLRESULTS, "vkCmdCopyQueryPoolResults()");
8048 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyQueryPoolResults()");
8050 skipCall |= insideRenderPass(dev_data, pCB, "vkCmdCopyQueryPoolResults");
8054 dev_data->device_dispatch_table->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer,
8062 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8064 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8067 skipCall |= addCmd(dev_data, pCB, CMD_PUSHCONSTANTS, "vkCmdPushConstants()");
8069 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdPushConstants()");
8072 skipCall |= validatePushConstantRange(dev_data, offset, size, "vkCmdPushConstants()");
8074 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8079 auto pipeline_layout = getPipelineLayout(dev_data, layout);
8081 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8102 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8141 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8152 dev_data->device_dispatch_table->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
8158 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8160 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8166 skipCall |= addCmd(dev_data, pCB, CMD_WRITETIMESTAMP, "vkCmdWriteTimestamp()");
8168 skipCall |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWriteTimestamp()");
8173 dev_data->device_dispatch_table->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
8179 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
8180 VkResult result = dev_data->device_dispatch_table->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
8185 auto & fbNode = dev_data->frameBufferMap[*pFramebuffer];
8196 auto view_data = dev_data->imageViewMap.find(view);
8197 if (view_data == dev_data->imageViewMap.end()) {
8201 get_mem_binding_from_object(dev_data, (uint64_t)(view_data->second.image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
8592 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
8598 skip_call |= CreatePassDAG(dev_data, device, pCreateInfo, subpass_to_node, has_self_dependency);
8600 skip_call |= ValidateLayouts(dev_data, device, pCreateInfo);
8605 VkResult result = dev_data->device_dispatch_table->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
8677 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8684 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8695 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8704 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8718 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8732 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8747 dev_data->renderPassMap[*pRenderPass] = render_pass;
8782 static bool VerifyFramebufferAndRenderPassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin) {
8784 const VkRenderPassCreateInfo *pRenderPassInfo = dev_data->renderPassMap[pRenderPassBegin->renderPass]->pCreateInfo;
8785 const VkFramebufferCreateInfo framebufferInfo = dev_data->frameBufferMap[pRenderPassBegin->framebuffer].createInfo;
8787 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8793 auto image_data = dev_data->imageViewMap.find(image_view);
8794 assert(image_data != dev_data->imageViewMap.end());
8812 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8825 static void TransitionSubpassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin,
8827 auto renderPass = getRenderPass(dev_data, pRenderPassBegin->renderPass);
8831 auto framebuffer = getFramebuffer(dev_data, pRenderPassBegin->framebuffer);
8839 SetLayout(dev_data, pCB, image_view, subpass.pInputAttachments[j].layout);
8843 SetLayout(dev_data, pCB, image_view, subpass.pColorAttachments[j].layout);
8847 SetLayout(dev_data, pCB, image_view, subpass.pDepthStencilAttachment->layout);
8861 static void TransitionFinalSubpassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin) {
8862 auto renderPass = getRenderPass(dev_data, pRenderPassBegin->renderPass);
8867 auto framebuffer = getFramebuffer(dev_data, pRenderPassBegin->framebuffer);
8873 SetLayout(dev_data, pCB, image_view, pRenderPassInfo->pAttachments[i].finalLayout);
8899 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8901 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8902 auto renderPass = pRenderPassBegin ? getRenderPass(dev_data, pRenderPassBegin->renderPass) : nullptr;
8903 auto framebuffer = pRenderPassBegin ? getFramebuffer(dev_data, pRenderPassBegin->framebuffer) : nullptr;
8912 set_memory_valid(dev_data, fb_info.mem, true, fb_info.image);
8918 set_memory_valid(dev_data, fb_info.mem, false, fb_info.image);
8924 return validate_memory_is_valid(dev_data, fb_info.mem, "vkCmdBeginRenderPass()", fb_info.image);
8930 return validate_memory_is_valid(dev_data, fb_info.mem, "vkCmdBeginRenderPass()", fb_info.image);
8936 skipCall |= VerifyRenderAreaBounds(dev_data, pRenderPassBegin);
8937 skipCall |= VerifyFramebufferAndRenderPassLayouts(dev_data, pCB, pRenderPassBegin);
8938 skipCall |= insideRenderPass(dev_data, pCB, "vkCmdBeginRenderPass");
8940 skipCall |= ValidateDependencies(dev_data, framebuffer, renderPass);
8943 skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdBeginRenderPass");
8944 skipCall |= addCmd(dev_data, pCB, CMD_BEGINRENDERPASS, "vkCmdBeginRenderPass()");
8954 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8960 dev_data->device_dispatch_table->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
8966 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8968 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8970 skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdNextSubpass");
8971 skipCall |= addCmd(dev_data, pCB, CMD_NEXTSUBPASS, "vkCmdNextSubpass()");
8974 TransitionSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo, pCB->activeSubpass);
8975 skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdNextSubpass");
8979 dev_data->device_dispatch_table->CmdNextSubpass(commandBuffer, contents);
8984 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8986 auto pCB = getCBNode(dev_data, commandBuffer);
8989 auto framebuffer = getFramebuffer(dev_data, pCB->activeFramebuffer);
8995 set_memory_valid(dev_data, fb_info.mem, true, fb_info.image);
9001 set_memory_valid(dev_data, fb_info.mem, false, fb_info.image);
9008 skipCall |= outsideRenderPass(dev_data, pCB, "vkCmdEndRenderpass");
9009 skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdEndRenderPass");
9010 skipCall |= addCmd(dev_data, pCB, CMD_ENDRENDERPASS, "vkCmdEndRenderPass()");
9011 TransitionFinalSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo);
9018 dev_data->device_dispatch_table->CmdEndRenderPass(commandBuffer);
9021 static bool logInvalidAttachmentMessage(layer_data *dev_data, VkCommandBuffer secondaryBuffer, RENDER_PASS_NODE const *secondaryPass,
9024 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9033 static bool validateAttachmentCompatibility(layer_data *dev_data, VkCommandBuffer primaryBuffer, RENDER_PASS_NODE const *primaryPass,
9047 skip_call |= logInvalidAttachmentMessage(dev_data, secondaryBuffer, secondaryPass, primaryPass, primaryAttach,
9052 skip_call |= logInvalidAttachmentMessage(dev_data, secondaryBuffer, secondaryPass, primaryPass, primaryAttach,
9058 skip_call |= logInvalidAttachmentMessage(dev_data, secondaryBuffer, secondaryPass, primaryPass, primaryAttach,
9063 skip_call |= logInvalidAttachmentMessage(dev_data, secondaryBuffer, secondaryPass, primaryPass, primaryAttach,
9069 skip_call |= logInvalidAttachmentMessage(dev_data, secondaryBuffer, secondaryPass, primaryPass, primaryAttach,
9075 static bool validateSubpassCompatibility(layer_data *dev_data, VkCommandBuffer primaryBuffer, RENDER_PASS_NODE const *primaryPass,
9090 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPass, primary_input_attach, secondaryBuffer,
9102 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPass, primary_color_attach, secondaryBuffer,
9111 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPass, primary_resolve_attach, secondaryBuffer,
9121 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPass, primary_depthstencil_attach, secondaryBuffer,
9126 static bool validateRenderPassCompatibility(layer_data *dev_data, VkCommandBuffer primaryBuffer, VkRenderPass primaryPass,
9132 auto primary_render_pass = getRenderPass(dev_data, primaryPass);
9133 auto secondary_render_pass = getRenderPass(dev_data, secondaryPass);
9136 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9144 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9151 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9161 skip_call |= validateSubpassCompatibility(dev_data, primaryBuffer, primary_render_pass, secondaryBuffer,
9167 static bool validateFramebuffer(layer_data *dev_data, VkCommandBuffer primaryBuffer, const GLOBAL_CB_NODE *pCB,
9177 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9183 auto fb = getFramebuffer(dev_data, secondary_fb);
9186 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9192 skip_call |= validateRenderPassCompatibility(dev_data, secondaryBuffer, fb->createInfo.renderPass,
9198 static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB, GLOBAL_CB_NODE *pSubCB) {
9202 auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool);
9203 if (queryPoolData != dev_data->queryPoolMap.end()) {
9209 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9221 auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool);
9222 if (queryPoolData != dev_data->queryPoolMap.end() && activeTypes.count(queryPoolData->second.createInfo.queryType)) {
9224 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9239 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9241 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9245 pSubCB = getCBNode(dev_data, pCommandBuffers[i]);
9248 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9253 skipCall |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
9261 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
9268 skipCall |= validateRenderPassCompatibility(dev_data, commandBuffer, pCB->activeRenderPass->renderPass, pCommandBuffers[i],
9270 skipCall |= validateFramebuffer(dev_data, commandBuffer, pCB, pCommandBuffers[i], pSubCB);
9273 if (!verify_renderpass_compatibility(dev_data, pCB->activeRenderPass->renderPass,
9276 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
9288 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
9298 skipCall |= validateSecondaryCommandBufferState(dev_data, pCB, pSubCB);
9299 skipCall |= validateCommandBufferState(dev_data, pSubCB);
9303 if (dev_data->globalInFlightCmdBuffers.find(pSubCB->commandBuffer) != dev_data->globalInFlightCmdBuffers.end()) {
9305 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
9314 dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
9324 if (!pCB->activeQueries.empty() && !dev_data->phys_dev_properties.features.inheritedQueries) {
9326 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
9336 dev_data->globalInFlightCmdBuffers.insert(pSubCB->commandBuffer);
9338 skipCall |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdExecuteComands");
9339 skipCall |= addCmd(dev_data, pCB, CMD_EXECUTECOMMANDS, "vkCmdExecuteComands()");
9343 dev_data->device_dispatch_table->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
9348 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9349 auto mem_data = dev_data->memObjMap.find(mem);
9350 if ((mem_data != dev_data->memObjMap.end()) && (mem_data->second.image != VK_NULL_HANDLE)) {
9352 if (FindLayouts(dev_data, mem_data->second.image, layouts)) {
9355 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
9368 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9374 DEVICE_MEM_INFO *pMemObj = get_mem_obj_info(dev_data, mem);
9377 if ((dev_data->phys_dev_mem_props.memoryTypes[pMemObj->allocInfo.memoryTypeIndex].propertyFlags &
9380 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
9385 skip_call |= validateMemRange(dev_data, mem, offset, size);
9391 result = dev_data->device_dispatch_table->MapMemory(device, mem, offset, size, flags, ppData);
9395 storeMemRanges(dev_data, mem, offset, size);
9396 initializeAndTrackMemory(dev_data, mem, size, ppData);
9511 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9515 auto image_node = dev_data->imageMap.find(image);
9516 if (image_node != dev_data->imageMap.end()) {
9519 skipCall = set_mem_binding(dev_data, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory");
9522 dev_data->device_dispatch_table->GetImageMemoryRequirements(device, image, &memRequirements);
9526 const auto &memEntry = dev_data->memObjMap.find(mem);
9527 if (memEntry != dev_data->memObjMap.end()) {
9531 validate_memory_range(dev_data, memEntry->second.bufferRanges, range, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
9534 print_mem_list(dev_data);
9537 result = dev_data->device_dispatch_table->BindImageMemory(device, image, mem, memoryOffset);
9539 dev_data->memObjMap[mem].image = image;
9546 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
9557 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9559 auto event_node = dev_data->eventMap.find(event);
9560 if (event_node != dev_data->eventMap.end()) {
9564 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
9574 for (auto queue_data : dev_data->queueMap) {
9581 result = dev_data->device_dispatch_table->SetEvent(device, event);
9587 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
9593 auto fence_data = dev_data->fenceMap.find(fence);
9596 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
9602 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
9607 trackCommandBuffers(dev_data, queue, 0, nullptr, fence);
9614 if (set_sparse_mem_binding(dev_data, bindInfo.pBufferBinds[j].pBinds[k].memory,
9622 if (set_sparse_mem_binding(dev_data, bindInfo.pImageOpaqueBinds[j].pBinds[k].memory,
9630 if (set_sparse_mem_binding(dev_data, bindInfo.pImageBinds[j].pBinds[k].memory,
9638 if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) {
9639 if (dev_data->semaphoreMap[semaphore].signaled) {
9640 dev_data->semaphoreMap[semaphore].signaled = false;
9643 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
9653 if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) {
9654 if (dev_data->semaphoreMap[semaphore].signaled) {
9656 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
9662 dev_data->semaphoreMap[semaphore].signaled = true;
9666 print_mem_list(dev_data);
9670 return dev_data->device_dispatch_table->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
9677 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9678 VkResult result = dev_data->device_dispatch_table->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
9681 SEMAPHORE_NODE* sNode = &dev_data->semaphoreMap[*pSemaphore];
9691 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9692 VkResult result = dev_data->device_dispatch_table->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
9695 dev_data->eventMap[*pEvent].needsSignaled = false;
9696 dev_data->eventMap[*pEvent].in_use.store(0);
9697 dev_data->eventMap[*pEvent].stageMask = VkPipelineStageFlags(0);
9705 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9706 VkResult result = dev_data->device_dispatch_table->CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
9711 dev_data->device_extensions.swapchainMap[*pSwapchain] = psc_node;
9719 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9723 auto swapchain_data = dev_data->device_extensions.swapchainMap.find(swapchain);
9724 if (swapchain_data != dev_data->device_extensions.swapchainMap.end()) {
9727 auto image_sub = dev_data->imageSubresourceMap.find(swapchain_image);
9728 if (image_sub != dev_data->imageSubresourceMap.end()) {
9730 auto image_item = dev_data->imageLayoutMap.find(imgsubpair);
9731 if (image_item != dev_data->imageLayoutMap.end()) {
9732 dev_data->imageLayoutMap.erase(image_item);
9735 dev_data->imageSubresourceMap.erase(image_sub);
9737 skipCall = clear_object_binding(dev_data, (uint64_t)swapchain_image,
9739 dev_data->imageMap.erase(swapchain_image);
9743 dev_data->device_extensions.swapchainMap.erase(swapchain);
9747 dev_data->device_dispatch_table->DestroySwapchainKHR(device, swapchain, pAllocator);
9752 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9753 VkResult result = dev_data->device_dispatch_table->GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
9761 auto swapchain_node = dev_data->device_extensions.swapchainMap[swapchain];
9768 log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
9779 auto &image_node = dev_data->imageMap[pSwapchainImages[i]];
9791 dev_data->imageSubresourceMap[pSwapchainImages[i]].push_back(subpair);
9792 dev_data->imageLayoutMap[subpair] = image_layout_node;
9793 dev_data->device_extensions.imageToSwapchainMap[pSwapchainImages[i]] = swapchain;
9800 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
9808 if (dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) {
9809 if (dev_data->semaphoreMap[semaphore].signaled) {
9810 dev_data->semaphoreMap[semaphore].signaled = false;
9813 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
9822 auto swapchain_data = dev_data->device_extensions.swapchainMap.find(pPresentInfo->pSwapchains[i]);
9823 if (swapchain_data != dev_data->device_extensions.swapchainMap.end() &&
9828 get_mem_binding_from_object(dev_data, (uint64_t)(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, &mem);
9829 skip_call |= validate_memory_is_valid(dev_data, mem, "vkQueuePresentKHR()", image);
9832 if (FindLayouts(dev_data, image, layouts)) {
9836 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
9849 result = dev_data->device_dispatch_table->QueuePresentKHR(queue, pPresentInfo);
9856 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9862 dev_data->semaphoreMap.find(semaphore) != dev_data->semaphoreMap.end()) {
9863 if (dev_data->semaphoreMap[semaphore].signaled) {
9864 skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
9868 dev_data->semaphoreMap[semaphore].signaled = true;
9870 auto fence_data = dev_data->fenceMap.find(fence);
9871 if (fence_data != dev_data->fenceMap.end()) {
9878 dev_data->device_dispatch_table->AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
9948 layer_data *dev_data;
9949 dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
9951 VkLayerDispatchTable *pTable = dev_data->device_dispatch_table;
10155 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
10156 if (!dev_data->device_extensions.wsi_enabled)
