Lines Matching refs:dev_data
279 IMAGE_VIEW_STATE *getImageViewState(const layer_data *dev_data, VkImageView image_view) {
280 auto iv_it = dev_data->imageViewMap.find(image_view);
281 if (iv_it == dev_data->imageViewMap.end()) {
287 SAMPLER_STATE *getSamplerState(const layer_data *dev_data, VkSampler sampler) {
288 auto sampler_it = dev_data->samplerMap.find(sampler);
289 if (sampler_it == dev_data->samplerMap.end()) {
295 IMAGE_STATE *getImageState(const layer_data *dev_data, VkImage image) {
296 auto img_it = dev_data->imageMap.find(image);
297 if (img_it == dev_data->imageMap.end()) {
303 BUFFER_NODE *getBufferNode(const layer_data *dev_data, VkBuffer buffer) {
304 auto buff_it = dev_data->bufferMap.find(buffer);
305 if (buff_it == dev_data->bufferMap.end()) {
311 SWAPCHAIN_NODE *getSwapchainNode(const layer_data *dev_data, VkSwapchainKHR swapchain) {
312 auto swp_it = dev_data->device_extensions.swapchainMap.find(swapchain);
313 if (swp_it == dev_data->device_extensions.swapchainMap.end()) {
319 VkSwapchainKHR getSwapchainFromImage(const layer_data *dev_data, VkImage image) {
320 auto img_it = dev_data->device_extensions.imageToSwapchainMap.find(image);
321 if (img_it == dev_data->device_extensions.imageToSwapchainMap.end()) {
335 FENCE_NODE *getFenceNode(layer_data *dev_data, VkFence fence) {
336 auto it = dev_data->fenceMap.find(fence);
337 if (it == dev_data->fenceMap.end()) {
343 EVENT_STATE *getEventNode(layer_data *dev_data, VkEvent event) {
344 auto it = dev_data->eventMap.find(event);
345 if (it == dev_data->eventMap.end()) {
351 QUERY_POOL_NODE *getQueryPoolNode(layer_data *dev_data, VkQueryPool query_pool) {
352 auto it = dev_data->queryPoolMap.find(query_pool);
353 if (it == dev_data->queryPoolMap.end()) {
359 QUEUE_NODE *getQueueNode(layer_data *dev_data, VkQueue queue) {
360 auto it = dev_data->queueMap.find(queue);
361 if (it == dev_data->queueMap.end()) {
367 SEMAPHORE_NODE *getSemaphoreNode(layer_data *dev_data, VkSemaphore semaphore) {
368 auto it = dev_data->semaphoreMap.find(semaphore);
369 if (it == dev_data->semaphoreMap.end()) {
375 COMMAND_POOL_NODE *getCommandPoolNode(layer_data *dev_data, VkCommandPool pool) {
376 auto it = dev_data->commandPoolMap.find(pool);
377 if (it == dev_data->commandPoolMap.end()) {
439 static bool ValidateImageUsageFlags(layer_data *dev_data, IMAGE_STATE const *image_state, VkFlags desired, VkBool32 strict,
441 return validate_usage_flags(dev_data, image_state->createInfo.usage, desired, strict,
449 static bool ValidateBufferUsageFlags(layer_data *dev_data, BUFFER_NODE const *buffer_node, VkFlags desired, VkBool32 strict,
451 return validate_usage_flags(dev_data, buffer_node->createInfo.usage, desired, strict,
458 DEVICE_MEM_INFO *getMemObjInfo(const layer_data *dev_data, const VkDeviceMemory mem) {
459 auto mem_it = dev_data->memObjMap.find(mem);
460 if (mem_it == dev_data->memObjMap.end()) {
515 static bool ValidateMemoryIsValid(layer_data *dev_data, VkDeviceMemory mem, uint64_t bound_object_handle,
517 DEVICE_MEM_INFO *mem_info = getMemObjInfo(dev_data, mem);
520 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
532 static bool ValidateImageMemoryIsValid(layer_data *dev_data, IMAGE_STATE *image_state, const char *functionName) {
535 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
541 return ValidateMemoryIsValid(dev_data, image_state->binding.mem, reinterpret_cast<uint64_t &>(image_state->image),
547 static bool ValidateBufferMemoryIsValid(layer_data *dev_data, BUFFER_NODE *buffer_node, const char *functionName) {
548 return ValidateMemoryIsValid(dev_data, buffer_node->binding.mem, reinterpret_cast<uint64_t &>(buffer_node->buffer),
552 static void SetMemoryValid(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle, bool valid) {
553 DEVICE_MEM_INFO *mem_info = getMemObjInfo(dev_data, mem);
561 static void SetImageMemoryValid(layer_data *dev_data, IMAGE_STATE *image_state, bool valid) {
565 SetMemoryValid(dev_data, image_state->binding.mem, reinterpret_cast<uint64_t &>(image_state->image), valid);
569 static void SetBufferMemoryValid(layer_data *dev_data, BUFFER_NODE *buffer_node, bool valid) {
570 SetMemoryValid(dev_data, buffer_node->binding.mem, reinterpret_cast<uint64_t &>(buffer_node->buffer), valid);
574 static bool update_cmd_buf_and_mem_references(layer_data *dev_data, const VkCommandBuffer cb, const VkDeviceMemory mem,
582 DEVICE_MEM_INFO *pMemInfo = getMemObjInfo(dev_data, mem);
585 GLOBAL_CB_NODE *cb_node = getCBNode(dev_data, cb);
604 void AddCommandBufferBindingImage(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, IMAGE_STATE *image_state) {
608 DEVICE_MEM_INFO *pMemInfo = getMemObjInfo(dev_data, image_state->binding.mem);
621 void AddCommandBufferBindingImageView(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, IMAGE_VIEW_STATE *view_state) {
626 auto image_state = getImageState(dev_data, view_state->create_info.image);
629 AddCommandBufferBindingImage(dev_data, cb_node, image_state);
634 void AddCommandBufferBindingBuffer(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, BUFFER_NODE *buff_node) {
636 DEVICE_MEM_INFO *pMemInfo = getMemObjInfo(dev_data, buff_node->binding.mem);
648 void AddCommandBufferBindingBufferView(const layer_data *dev_data, GLOBAL_CB_NODE *cb_node, BUFFER_VIEW_STATE *view_state) {
653 auto buffer_node = getBufferNode(dev_data, view_state->create_info.buffer);
656 AddCommandBufferBindingBuffer(dev_data, cb_node, buffer_node);
661 static void clear_cmd_buf_and_mem_references(layer_data *dev_data, GLOBAL_CB_NODE *cb_node) {
665 DEVICE_MEM_INFO *pInfo = getMemObjInfo(dev_data, mem);
676 static void clear_cmd_buf_and_mem_references(layer_data *dev_data, const VkCommandBuffer cb) {
677 clear_cmd_buf_and_mem_references(dev_data, getCBNode(dev_data, cb));
681 static bool ClearMemoryObjectBinding(layer_data *dev_data, uint64_t handle, VkDebugReportObjectTypeEXT type, VkDeviceMemory mem) {
682 DEVICE_MEM_INFO *mem_info = getMemObjInfo(dev_data, mem);
685 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT,
696 static bool ClearMemoryObjectBindings(layer_data *dev_data, uint64_t handle, VkDebugReportObjectTypeEXT type) {
698 BINDABLE *mem_binding = GetObjectMemBinding(dev_data, handle, type);
701 skip = ClearMemoryObjectBinding(dev_data, handle, type, mem_binding->binding.mem);
704 skip |= ClearMemoryObjectBinding(dev_data, handle, type, sparse_mem_binding.mem);
712 bool VerifyBoundMemoryIsValid(const layer_data *dev_data, VkDeviceMemory mem, uint64_t handle, const char *api_name,
716 result = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, handle,
722 result = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, handle,
732 bool ValidateMemoryIsBoundToImage(const layer_data *dev_data, const IMAGE_STATE *image_state, const char *api_name) {
735 result = VerifyBoundMemoryIsValid(dev_data, image_state->binding.mem, reinterpret_cast<const uint64_t &>(image_state->image),
742 bool ValidateMemoryIsBoundToBuffer(const layer_data *dev_data, const BUFFER_NODE *buffer_node, const char *api_name) {
745 result = VerifyBoundMemoryIsValid(dev_data, buffer_node->binding.mem,
757 static bool SetMemBinding(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle, VkDebugReportObjectTypeEXT type,
762 skip_call = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_MEM_OBJ,
765 BINDABLE *mem_binding = GetObjectMemBinding(dev_data, handle, type);
771 DEVICE_MEM_INFO *mem_info = getMemObjInfo(dev_data, mem);
773 DEVICE_MEM_INFO *prev_binding = getMemObjInfo(dev_data, mem_binding->binding.mem);
776 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
783 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
794 auto const image_state = getImageState(dev_data, VkImage(handle));
815 static bool SetSparseMemBinding(layer_data *dev_data, MEM_BINDING binding, uint64_t handle, VkDebugReportObjectTypeEXT type,
822 BINDABLE *mem_binding = GetObjectMemBinding(dev_data, handle, type);
825 DEVICE_MEM_INFO *mem_info = getMemObjInfo(dev_data, binding.mem);
836 static bool get_mem_for_type(layer_data *dev_data, uint64_t handle, VkDebugReportObjectTypeEXT type, VkDeviceMemory *mem) {
841 *mem = getImageState(dev_data, VkImage(handle))->binding.mem;
844 *mem = getBufferNode(dev_data, VkBuffer(handle))->binding.mem;
850 skip_call = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT,
859 static void print_mem_list(layer_data *dev_data) {
861 if (!(dev_data->report_data->active_flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)) {
866 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__,
868 dev_data->memObjMap.size());
869 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0, __LINE__,
872 if (dev_data->memObjMap.size() <= 0)
875 for (auto ii = dev_data->memObjMap.begin(); ii != dev_data->memObjMap.end(); ++ii) {
878 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
880 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
882 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
887 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
890 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
894 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
899 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
904 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, 0,
910 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
2269 static bool validate_draw_state_flags(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const PIPELINE_STATE *pPipe, bool indexedDraw) {
2274 result |= validate_status(dev_data, pCB, CBSTATUS_LINE_WIDTH_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2279 result |= validate_status(dev_data, pCB, CBSTATUS_DEPTH_BIAS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2283 result |= validate_status(dev_data, pCB, CBSTATUS_BLEND_CONSTANTS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2288 result |= validate_status(dev_data, pCB, CBSTATUS_DEPTH_BOUNDS_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2293 result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_READ_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2295 result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_WRITE_MASK_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2297 result |= validate_status(dev_data, pCB, CBSTATUS_STENCIL_REFERENCE_SET, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2301 result |= validate_status(dev_data, pCB, CBSTATUS_INDEX_BUFFER_BOUND, VK_DEBUG_REPORT_ERROR_BIT_EXT,
2945 layer_data *dev_data, GLOBAL_CB_NODE *pCB,
2957 result |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
3479 DESCRIPTOR_POOL_STATE *getDescriptorPoolState(const layer_data *dev_data, const VkDescriptorPool pool) {
3480 auto pool_it = dev_data->descriptorPoolMap.find(pool);
3481 if (pool_it == dev_data->descriptorPoolMap.end()) {
3729 void SetLayout(const layer_data *dev_data, GLOBAL_CB_NODE *pCB, VkImageView imageView, const VkImageLayout &layout) {
3730 auto view_state = getImageViewState(dev_data, imageView);
3757 static bool validateIdleDescriptorSet(const layer_data *dev_data, VkDescriptorSet set, std::string func_str) {
3758 if (dev_data->instance_data->disabled.idle_descriptor_set)
3761 auto set_node = dev_data->setMap.find(set);
3762 if (set_node == dev_data->setMap.end()) {
3763 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
3771 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT,
3781 static void freeDescriptorSet(layer_data *dev_data, cvdescriptorset::DescriptorSet *descriptor_set) {
3782 dev_data->setMap.erase(descriptor_set->GetSet());
3839 static bool report_error_no_cb_begin(const layer_data *dev_data, const VkCommandBuffer cb, const char *caller_name) {
3840 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
3845 bool validateCmdsInCmdBuffer(const layer_data *dev_data, const GLOBAL_CB_NODE *pCB, const CMD_TYPE cmd_type) {
3851 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
3855 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
3964 BASE_NODE *GetStateStructPtrFromObject(layer_data *dev_data, VK_OBJECT object_struct) {
3968 base_ptr = getSetNode(dev_data, reinterpret_cast<VkDescriptorSet &>(object_struct.handle));
3972 base_ptr = getSamplerState(dev_data, reinterpret_cast<VkSampler &>(object_struct.handle));
3976 base_ptr = getQueryPoolNode(dev_data, reinterpret_cast<VkQueryPool &>(object_struct.handle));
3980 base_ptr = getPipelineState(dev_data, reinterpret_cast<VkPipeline &>(object_struct.handle));
3984 base_ptr = getBufferNode(dev_data, reinterpret_cast<VkBuffer &>(object_struct.handle));
3988 base_ptr = getBufferViewState(dev_data, reinterpret_cast<VkBufferView &>(object_struct.handle));
3992 base_ptr = getImageState(dev_data, reinterpret_cast<VkImage &>(object_struct.handle));
3996 base_ptr = getImageViewState(dev_data, reinterpret_cast<VkImageView &>(object_struct.handle));
4000 base_ptr = getEventNode(dev_data, reinterpret_cast<VkEvent &>(object_struct.handle));
4004 base_ptr = getDescriptorPoolState(dev_data, reinterpret_cast<VkDescriptorPool &>(object_struct.handle));
4008 base_ptr = getCommandPoolNode(dev_data, reinterpret_cast<VkCommandPool &>(object_struct.handle));
4012 base_ptr = getFramebufferState(dev_data, reinterpret_cast<VkFramebuffer &>(object_struct.handle));
4016 base_ptr = getRenderPassState(dev_data, reinterpret_cast<VkRenderPass &>(object_struct.handle));
4020 base_ptr = getMemObjInfo(dev_data, reinterpret_cast<VkDeviceMemory &>(object_struct.handle));
4039 static void removeCommandBufferBinding(layer_data *dev_data, VK_OBJECT const *object, GLOBAL_CB_NODE *cb_node) {
4040 BASE_NODE *base_obj = GetStateStructPtrFromObject(dev_data, *object);
4046 static void resetCB(layer_data *dev_data, const VkCommandBuffer cb) {
4047 GLOBAL_CB_NODE *pCB = dev_data->commandBufferMap[cb];
4087 dev_data->globalInFlightCmdBuffers.erase(secondary_cb);
4092 clear_cmd_buf_and_mem_references(dev_data, pCB);
4098 removeCommandBufferBinding(dev_data, &obj, pCB);
4103 auto fb_state = getFramebufferState(dev_data, framebuffer);
4321 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
4322 dev_data->device_extensions.wsi_enabled = false;
4323 dev_data->device_extensions.wsi_display_swapchain_enabled = false;
4327 dev_data->device_extensions.wsi_enabled = true;
4329 dev_data->device_extensions.wsi_display_swapchain_enabled = true;
4372 static bool ValidateRequestedFeatures(instance_layer_data *dev_data, VkPhysicalDevice phys, const VkPhysicalDeviceFeatures *requested_features) {
4375 auto phys_device_state = getPhysicalDeviceState(dev_data, phys);
4386 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
4397 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
4475 layer_data *dev_data = get_my_data_ptr(key, layer_data_map);
4478 deletePipelines(dev_data);
4479 dev_data->renderPassMap.clear();
4480 deleteCommandBuffers(dev_data);
4482 deletePools(dev_data);
4484 assert(dev_data->setMap.empty());
4485 for (auto del_layout : dev_data->descriptorSetLayoutMap) {
4488 dev_data->descriptorSetLayoutMap.clear();
4489 dev_data->imageViewMap.clear();
4490 dev_data->imageMap.clear();
4491 dev_data->imageSubresourceMap.clear();
4492 dev_data->imageLayoutMap.clear();
4493 dev_data->bufferViewMap.clear();
4494 dev_data->bufferMap.clear();
4496 dev_data->queueMap.clear();
4497 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
4499 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
4501 print_mem_list(dev_data);
4502 printCBList(dev_data);
4505 if (!dev_data->memObjMap.empty()) {
4506 for (auto ii = dev_data->memObjMap.begin(); ii != dev_data->memObjMap.end(); ++ii) {
4510 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
4525 dev_data->dispatch_table.DestroyDevice(device, pAllocator);
4535 static bool ValidateCmdBufImageLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
4539 if (!FindLayout(dev_data, cb_image_data.first, imageLayout)) {
4541 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4550 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4560 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4568 SetLayout(dev_data, cb_image_data.first, cb_image_data.second.layout);
4576 static bool ValidateAndIncrementBoundObjects(layer_data *dev_data, GLOBAL_CB_NODE const *cb_node) {
4583 base_obj = getSetNode(dev_data, reinterpret_cast<VkDescriptorSet &>(obj.handle));
4588 base_obj = getSamplerState(dev_data, reinterpret_cast<VkSampler &>(obj.handle));
4593 base_obj = getQueryPoolNode(dev_data, reinterpret_cast<VkQueryPool &>(obj.handle));
4598 base_obj = getPipelineState(dev_data, reinterpret_cast<VkPipeline &>(obj.handle));
4603 base_obj = getBufferNode(dev_data, reinterpret_cast<VkBuffer &>(obj.handle));
4608 base_obj = getBufferViewState(dev_data, reinterpret_cast<VkBufferView &>(obj.handle));
4613 base_obj = getImageState(dev_data, reinterpret_cast<VkImage &>(obj.handle));
4618 base_obj = getImageViewState(dev_data, reinterpret_cast<VkImageView &>(obj.handle));
4623 base_obj = getEventNode(dev_data, reinterpret_cast<VkEvent &>(obj.handle));
4628 base_obj = getDescriptorPoolState(dev_data, reinterpret_cast<VkDescriptorPool &>(obj.handle));
4633 base_obj = getCommandPoolNode(dev_data, reinterpret_cast<VkCommandPool &>(obj.handle));
4638 base_obj = getFramebufferState(dev_data, reinterpret_cast<VkFramebuffer &>(obj.handle));
4643 base_obj = getRenderPassState(dev_data, reinterpret_cast<VkRenderPass &>(obj.handle));
4648 base_obj = getMemObjInfo(dev_data, reinterpret_cast<VkDeviceMemory &>(obj.handle));
4658 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, obj.type, obj.handle, __LINE__, error_code, "DS",
4668 static bool validateAndIncrementResources(layer_data *dev_data, GLOBAL_CB_NODE *cb_node) {
4672 dev_data->globalInFlightCmdBuffers.insert(cb_node->commandBuffer);
4675 skip_call |= ValidateAndIncrementBoundObjects(dev_data, cb_node);
4681 auto buffer_node = getBufferNode(dev_data, buffer);
4683 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT,
4692 auto event_state = getEventNode(dev_data, event);
4723 static inline void removeInFlightCmdBuffer(layer_data *dev_data, VkCommandBuffer cmd_buffer) {
4725 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmd_buffer);
4728 dev_data->globalInFlightCmdBuffers.erase(cmd_buffer);
4733 static void DecrementBoundResources(layer_data *dev_data, GLOBAL_CB_NODE const *cb_node) {
4736 base_obj = GetStateStructPtrFromObject(dev_data, obj);
4743 static bool RetireWorkOnQueue(layer_data *dev_data, QUEUE_NODE *pQueue, uint64_t seq)
4753 auto pSemaphore = getSemaphoreNode(dev_data, wait.semaphore);
4760 auto pSemaphore = getSemaphoreNode(dev_data, semaphore);
4765 auto cb_node = getCBNode(dev_data, cb);
4767 DecrementBoundResources(dev_data, cb_node);
4770 auto buffer_node = getBufferNode(dev_data, buffer);
4777 auto eventNode = dev_data->eventMap.find(event);
4778 if (eventNode != dev_data->eventMap.end()) {
4783 dev_data->queryToStateMap[queryStatePair.first] = queryStatePair.second;
4786 dev_data->eventMap[eventStagePair.first].stageMask = eventStagePair.second;
4789 skip_call |= cleanInFlightCmdBuffer(dev_data, cb);
4790 removeInFlightCmdBuffer(dev_data, cb);
4793 auto pFence = getFenceNode(dev_data, submission.fence);
4804 skip_call |= RetireWorkOnQueue(dev_data, getQueueNode(dev_data, qs.first), qs.second);
4821 static bool validateCommandBufferSimultaneousUse(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
4823 if (dev_data->globalInFlightCmdBuffers.count(pCB->commandBuffer) &&
4826 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4834 static bool validateCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const char *call_source) {
4836 if (dev_data->instance_data->disabled.command_buffer_state)
4840 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4857 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4864 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4875 static bool validateQueueFamilyIndices(layer_data *dev_data, GLOBAL_CB_NODE *pCB, VkQueue queue) {
4877 auto pPool = getCommandPoolNode(dev_data, pCB->createInfo.commandPool);
4878 auto queue_node = getQueueNode(dev_data, queue);
4881 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
4892 static bool validatePrimaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB) {
4898 skip_call |= validateCommandBufferSimultaneousUse(dev_data, pCB);
4900 skip_call |= validateAndIncrementResources(dev_data, pCB);
4904 GLOBAL_CB_NODE *pSubCB = getCBNode(dev_data, secondaryCmdBuffer);
4905 skip_call |= validateAndIncrementResources(dev_data, pSubCB);
4908 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
4920 skip_call |= validateCommandBufferState(dev_data, pCB, "vkQueueSubmit()");
4926 ValidateFenceForSubmit(layer_data *dev_data, FENCE_NODE *pFence)
4932 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
4939 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
4953 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
4957 auto pQueue = getQueueNode(dev_data, queue);
4958 auto pFence = getFenceNode(dev_data, fence);
4959 skip_call |= ValidateFenceForSubmit(dev_data, pFence);
4966 print_mem_list(dev_data);
4967 printCBList(dev_data);
4981 auto pSemaphore = getSemaphoreNode(dev_data, semaphore);
4992 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
5001 auto pSemaphore = getSemaphoreNode(dev_data, semaphore);
5005 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
5024 auto cb_node = getCBNode(dev_data, submit->pCommandBuffers[i]);
5025 skip_call |= ValidateCmdBufImageLayouts(dev_data, cb_node);
5033 skip_call |= validatePrimaryCommandBufferState(dev_data, cb_node);
5034 skip_call |= validateQueueFamilyIndices(dev_data, cb_node, queue);
5067 result = dev_data->dispatch_table.QueueSubmit(queue, submitCount, pSubmits, fence);
5084 bool ValidateObjectNotInUse(const layer_data *dev_data, BASE_NODE *obj_node, VK_OBJECT obj_struct,
5086 if (dev_data->instance_data->disabled.object_in_use)
5090 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, obj_struct.type, obj_struct.handle, __LINE__,
5097 static bool PreCallValidateFreeMemory(layer_data *dev_data, VkDeviceMemory mem, DEVICE_MEM_INFO **mem_info, VK_OBJECT *obj_struct) {
5098 *mem_info = getMemObjInfo(dev_data, mem);
5100 if (dev_data->instance_data->disabled.free_memory)
5104 skip |= ValidateObjectNotInUse(dev_data, *mem_info, *obj_struct, VALIDATION_ERROR_00620);
5109 static void PostCallRecordFreeMemory(layer_data *dev_data, VkDeviceMemory mem, DEVICE_MEM_INFO *mem_info, VK_OBJECT obj_struct) {
5112 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, obj.type, obj.handle, __LINE__, MEMTRACK_FREED_MEM_REF,
5117 auto image_state = getImageState(dev_data, reinterpret_cast<VkImage &>(obj.handle));
5123 auto buff_node = getBufferNode(dev_data, reinterpret_cast<VkBuffer &>(obj.handle));
5135 dev_data->memObjMap.erase(mem);
5139 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5143 bool skip = PreCallValidateFreeMemory(dev_data, mem, &mem_info, &obj_struct);
5146 dev_data->dispatch_table.FreeMemory(device, mem, pAllocator);
5148 PostCallRecordFreeMemory(dev_data, mem, mem_info, obj_struct);
5228 static void initializeAndTrackMemory(layer_data *dev_data, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size,
5230 auto mem_info = getMemObjInfo(dev_data, mem);
5234 if (dev_data->phys_dev_mem_props.memoryTypes[index].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) {
5240 mem_info->shadow_pad_size = dev_data->phys_dev_properties.properties.limits.minMemoryMapAlignment;
5242 dev_data->phys_dev_properties.properties.limits.minMemoryMapAlignment) == 0);
5244 uint64_t map_alignment = dev_data->phys_dev_properties.properties.limits.minMemoryMapAlignment;
5266 static inline bool verifyWaitFenceState(layer_data *dev_data, VkFence fence, const char *apiCall) {
5269 auto pFence = getFenceNode(dev_data, fence);
5272 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
5282 static bool RetireFence(layer_data *dev_data, VkFence fence) {
5283 auto pFence = getFenceNode(dev_data, fence);
5288 return RetireWorkOnQueue(dev_data,
5289 getQueueNode(dev_data, pFence->signaler.first),
5303 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5308 skip_call |= verifyWaitFenceState(dev_data, pFences[i], "vkWaitForFences");
5314 VkResult result = dev_data->dispatch_table.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
5321 skip_call |= RetireFence(dev_data, pFences[i]);
5335 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5338 skip_call = verifyWaitFenceState(dev_data, fence, "vkGetFenceStatus");
5344 VkResult result = dev_data->dispatch_table.GetFenceStatus(device, fence);
5347 skip_call |= RetireFence(dev_data, fence);
5357 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5358 dev_data->dispatch_table.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue);
5362 auto result = dev_data->queues.emplace(*pQueue);
5364 QUEUE_NODE *pQNode = &dev_data->queueMap[*pQueue];
5372 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
5375 auto pQueue = getQueueNode(dev_data, queue);
5376 skip_call |= RetireWorkOnQueue(dev_data, pQueue, pQueue->seq + pQueue->submissions.size());
5380 VkResult result = dev_data->dispatch_table.QueueWaitIdle(queue);
5386 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5388 for (auto & queue : dev_data->queueMap) {
5389 skip_call |= RetireWorkOnQueue(dev_data, &queue.second, queue.second.seq + queue.second.submissions.size());
5394 VkResult result = dev_data->dispatch_table.DeviceWaitIdle(device);
5399 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5402 auto fence_pair = dev_data->fenceMap.find(fence);
5403 if (fence_pair != dev_data->fenceMap.end()) {
5405 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
5409 dev_data->fenceMap.erase(fence_pair);
5414 dev_data->dispatch_table.DestroyFence(device, fence, pAllocator);
5419 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5422 auto sema_node = getSemaphoreNode(dev_data, semaphore);
5424 skip |= ValidateObjectNotInUse(dev_data, sema_node,
5429 dev_data->semaphoreMap.erase(semaphore);
5431 dev_data->dispatch_table.DestroySemaphore(device, semaphore, pAllocator);
5435 static bool PreCallValidateDestroyEvent(layer_data *dev_data, VkEvent event, EVENT_STATE **event_state, VK_OBJECT *obj_struct) {
5436 *event_state = getEventNode(dev_data, event);
5438 if (dev_data->instance_data->disabled.destroy_event)
5442 skip |= ValidateObjectNotInUse(dev_data, *event_state, *obj_struct, VALIDATION_ERROR_00213);
5447 static void PostCallRecordDestroyEvent(layer_data *dev_data, VkEvent event, EVENT_STATE *event_state, VK_OBJECT obj_struct) {
5449 dev_data->eventMap.erase(event);
5453 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5457 bool skip = PreCallValidateDestroyEvent(dev_data, event, &event_state, &obj_struct);
5460 dev_data->dispatch_table.DestroyEvent(device, event, pAllocator);
5462 PostCallRecordDestroyEvent(dev_data, event, event_state, obj_struct);
5468 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5471 auto qp_node = getQueryPoolNode(dev_data, queryPool);
5474 skip |= ValidateObjectNotInUse(dev_data, qp_node, obj_struct, VALIDATION_ERROR_01012);
5479 dev_data->queryPoolMap.erase(queryPool);
5481 dev_data->dispatch_table.DestroyQueryPool(device, queryPool, pAllocator);
5488 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5491 for (auto cmdBuffer : dev_data->globalInFlightCmdBuffers) {
5492 auto pCB = getCBNode(dev_data, cmdBuffer);
5501 auto queryToStateElement = dev_data->queryToStateMap.find(query);
5502 if (queryToStateElement != dev_data->queryToStateMap.end()) {
5504 if (queryElement != queriesInFlight.end() && queryToStateElement != dev_data->queryToStateMap.end() &&
5507 auto pCB = getCBNode(dev_data, cmdBuffer);
5510 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
5516 dev_data->eventMap[event].needsSignaled = true;
5521 } else if (queryElement != queriesInFlight.end() && queryToStateElement != dev_data->queryToStateMap.end() &&
5526 auto pCB = getCBNode(dev_data, cmdBuffer);
5530 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
5536 } else if (queryToStateElement != dev_data->queryToStateMap.end() && !queryToStateElement->second) {
5537 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
5542 } else if (queryToStateElement == dev_data->queryToStateMap.end()) {
5543 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
5554 return dev_data->dispatch_table.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
5580 static bool rangesIntersect(layer_data const *dev_data, MEMORY_RANGE const *range1, MEMORY_RANGE const *range2, bool *skip_call) {
5588 pad_align = dev_data->phys_dev_properties.properties.limits.bufferImageGranularity;
5603 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, obj_type, range1->handle, 0, MEMTRACK_INVALID_ALIASING,
5612 static bool rangesIntersect(layer_data const *dev_data, MEMORY_RANGE const *range1, VkDeviceSize offset, VkDeviceSize end) {
5620 return rangesIntersect(dev_data, range1, &range_wrap, &tmp_bool);
5624 static void SetMemRangesValid(layer_data const *dev_data, DEVICE_MEM_INFO *mem_info, VkDeviceSize offset, VkDeviceSize end) {
5631 if (rangesIntersect(dev_data, &handle_range_pair.second, &map_range, &tmp_bool)) {
5644 static bool InsertMemoryRange(layer_data const *dev_data, uint64_t handle, DEVICE_MEM_INFO *mem_info, VkDeviceSize memoryOffset,
5665 if (rangesIntersect(dev_data, &range, check_range, &intersection_error)) {
5683 static bool InsertImageMemoryRange(layer_data const *dev_data, VkImage image, DEVICE_MEM_INFO *mem_info, VkDeviceSize mem_offset,
5685 return InsertMemoryRange(dev_data, reinterpret_cast<uint64_t &>(image), mem_info, mem_offset, mem_reqs, true, is_linear);
5688 static bool InsertBufferMemoryRange(layer_data const *dev_data, VkBuffer buffer, DEVICE_MEM_INFO *mem_info, VkDeviceSize mem_offset,
5690 return InsertMemoryRange(dev_data, reinterpret_cast<uint64_t &>(buffer), mem_info, mem_offset, mem_reqs, false, true);
5717 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5719 if (!validateIdleBuffer(dev_data, buffer)) {
5721 auto buff_node = getBufferNode(dev_data, buffer);
5726 auto mem_info = getMemObjInfo(dev_data, buff_node->binding.mem);
5730 ClearMemoryObjectBindings(dev_data, reinterpret_cast<uint64_t &>(buffer), VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
5731 dev_data->bufferMap.erase(buff_node->buffer);
5734 dev_data->dispatch_table.DestroyBuffer(device, buffer, pAllocator);
5738 static bool PreCallValidateDestroyBufferView(layer_data *dev_data, VkBufferView buffer_view, BUFFER_VIEW_STATE **buffer_view_state,
5740 *buffer_view_state = getBufferViewState(dev_data, buffer_view);
5742 if (dev_data->instance_data->disabled.destroy_buffer_view)
5746 skip |= ValidateObjectNotInUse(dev_data, *buffer_view_state, *obj_struct, VALIDATION_ERROR_00701);
5751 static void PostCallRecordDestroyBufferView(layer_data *dev_data, VkBufferView buffer_view, BUFFER_VIEW_STATE *buffer_view_state,
5755 dev_data->bufferViewMap.erase(buffer_view);
5760 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5766 bool skip = PreCallValidateDestroyBufferView(dev_data, bufferView, &buffer_view_state, &obj_struct);
5769 dev_data->dispatch_table.DestroyBufferView(device, bufferView, pAllocator);
5771 PostCallRecordDestroyBufferView(dev_data, bufferView, buffer_view_state, obj_struct);
5775 static bool PreCallValidateDestroyImage(layer_data *dev_data, VkImage image, IMAGE_STATE **image_state, VK_OBJECT *obj_struct) {
5776 *image_state = getImageState(dev_data, image);
5778 if (dev_data->instance_data->disabled.destroy_image)
5782 skip |= ValidateObjectNotInUse(dev_data, *image_state, *obj_struct, VALIDATION_ERROR_00743);
5787 static void PostCallRecordDestroyImage(layer_data *dev_data, VkImage image, IMAGE_STATE *image_state, VK_OBJECT obj_struct) {
5790 auto mem_info = getMemObjInfo(dev_data, image_state->binding.mem);
5794 ClearMemoryObjectBindings(dev_data, obj_struct.handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
5796 dev_data->imageMap.erase(image);
5798 const auto &sub_entry = dev_data->imageSubresourceMap.find(image);
5799 if (sub_entry != dev_data->imageSubresourceMap.end()) {
5801 dev_data->imageLayoutMap.erase(pair);
5803 dev_data->imageSubresourceMap.erase(sub_entry);
5808 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5812 bool skip = PreCallValidateDestroyImage(dev_data, image, &image_state, &obj_struct);
5815 dev_data->dispatch_table.DestroyImage(device, image, pAllocator);
5817 PostCallRecordDestroyImage(dev_data, image, image_state, obj_struct);
5821 static bool ValidateMemoryTypes(const layer_data *dev_data, const DEVICE_MEM_INFO *mem_info, const uint32_t memory_type_bits,
5826 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
5837 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5842 bool skip_call = SetMemBinding(dev_data, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory");
5843 auto buffer_node = getBufferNode(dev_data, buffer);
5846 dev_data->dispatch_table.GetBufferMemoryRequirements(device, buffer, &memRequirements);
5852 auto mem_info = getMemObjInfo(dev_data, mem);
5854 skip_call |= InsertBufferMemoryRange(dev_data, buffer, mem_info, memoryOffset, memRequirements);
5855 skip_call |= ValidateMemoryTypes(dev_data, mem_info, memRequirements.memoryTypeBits, "BindBufferMemory");
5861 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT, 0,
5885 dev_data->phys_dev_properties.properties.limits.minTexelBufferOffsetAlignment,
5886 dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment,
5887 dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment
5889 VkBufferUsageFlags usage = dev_data->bufferMap[buffer].get()->createInfo.usage;
5895 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT,
5904 print_mem_list(dev_data);
5907 result = dev_data->dispatch_table.BindBufferMemory(device, buffer, mem, memoryOffset);
5928 static bool PreCallValidateDestroyImageView(layer_data *dev_data, VkImageView image_view, IMAGE_VIEW_STATE **image_view_state,
5930 *image_view_state = getImageViewState(dev_data, image_view);
5932 if (dev_data->instance_data->disabled.destroy_image_view)
5936 skip |= ValidateObjectNotInUse(dev_data, *image_view_state, *obj_struct, VALIDATION_ERROR_00776);
5941 static void PostCallRecordDestroyImageView(layer_data *dev_data, VkImageView image_view, IMAGE_VIEW_STATE *image_view_state,
5945 dev_data->imageViewMap.erase(image_view);
5950 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
5955 bool skip = PreCallValidateDestroyImageView(dev_data, imageView, &image_view_state, &obj_struct);
5958 dev_data->dispatch_table.DestroyImageView(device, imageView, pAllocator);
5960 PostCallRecordDestroyImageView(dev_data, imageView, image_view_state, obj_struct);
5975 static bool PreCallValidateDestroyPipeline(layer_data *dev_data, VkPipeline pipeline, PIPELINE_STATE **pipeline_state,
5977 *pipeline_state = getPipelineState(dev_data, pipeline);
5979 if (dev_data->instance_data->disabled.destroy_pipeline)
5983 skip |= ValidateObjectNotInUse(dev_data, *pipeline_state, *obj_struct, VALIDATION_ERROR_00555);
5988 static void PostCallRecordDestroyPipeline(layer_data *dev_data
5992 dev_data->pipelineMap.erase(pipeline);
5997 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6001 bool skip = PreCallValidateDestroyPipeline(dev_data, pipeline, &pipeline_state, &obj_struct);
6004 dev_data->dispatch_table.DestroyPipeline(device, pipeline, pAllocator);
6006 PostCallRecordDestroyPipeline(dev_data, pipeline, pipeline_state, obj_struct);
6012 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6014 dev_data->pipelineLayoutMap.erase(pipelineLayout);
6017 dev_data->dispatch_table.DestroyPipelineLayout(device, pipelineLayout, pAllocator);
6020 static bool PreCallValidateDestroySampler(layer_data *dev_data, VkSampler sampler, SAMPLER_STATE **sampler_state,
6022 *sampler_state = getSamplerState(dev_data, sampler);
6024 if (dev_data->instance_data->disabled.destroy_sampler)
6028 skip |= ValidateObjectNotInUse(dev_data, *sampler_state, *obj_struct, VALIDATION_ERROR_00837);
6033 static void PostCallRecordDestroySampler(layer_data *dev_data, VkSampler sampler, SAMPLER_STATE *sampler_state,
6038 dev_data->samplerMap.erase(sampler);
6043 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6047 bool skip = PreCallValidateDestroySampler(dev_data, sampler, &sampler_state, &obj_struct);
6050 dev_data->dispatch_table.DestroySampler(device, sampler, pAllocator);
6052 PostCallRecordDestroySampler(dev_data, sampler, sampler_state, obj_struct);
6063 static bool PreCallValidateDestroyDescriptorPool(layer_data *dev_data, VkDescriptorPool pool,
6065 *desc_pool_state = getDescriptorPoolState(dev_data, pool);
6067 if (dev_data->instance_data->disabled.destroy_descriptor_pool)
6071 skip |= ValidateObjectNotInUse(dev_data, *desc_pool_state, *obj_struct, VALIDATION_ERROR_00901);
6076 static void PostCallRecordDestroyDescriptorPool(layer_data *dev_data, VkDescriptorPool descriptorPool,
6082 freeDescriptorSet(dev_data, ds);
6084 dev_data->descriptorPoolMap.erase(descriptorPool);
6089 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6093 bool skip = PreCallValidateDestroyDescriptorPool(dev_data, descriptorPool, &desc_pool_state, &obj_struct);
6096 dev_data->dispatch_table.DestroyDescriptorPool(device, descriptorPool, pAllocator);
6098 PostCallRecordDestroyDescriptorPool(dev_data, descriptorPool, desc_pool_state, obj_struct);
6105 static bool checkCommandBufferInFlight(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const char *action,
6108 if (dev_data->globalInFlightCmdBuffers.count(cb_node->commandBuffer)) {
6111 (dev_data->globalInFlightCmdBuffers.count(cb_node->primaryCommandBuffer))) {
6113 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
6123 static bool checkCommandBuffersInFlight(layer_data *dev_data, COMMAND_POOL_NODE *pPool, const char *action,
6127 if (dev_data->globalInFlightCmdBuffers.count(cmd_buffer)) {
6128 skip_call |= checkCommandBufferInFlight(dev_data, getCBNode(dev_data, cmd_buffer), action, error_code);
6134 static void clearCommandBuffersInFlight(layer_data *dev_data, COMMAND_POOL_NODE *pPool) {
6136 dev_data->globalInFlightCmdBuffers.erase(cmd_buffer);
6142 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6147 auto cb_node = getCBNode(dev_data, pCommandBuffers[i]);
6150 skip_call |= checkCommandBufferInFlight(dev_data, cb_node, "free", VALIDATION_ERROR_00096);
6157 auto pPool = getCommandPoolNode(dev_data, commandPool);
6159 auto cb_node = getCBNode(dev_data, pCommandBuffers[i]);
6162 dev_data->globalInFlightCmdBuffers.erase(cb_node->commandBuffer);
6164 resetCB(dev_data, cb_node->commandBuffer);
6165 dev_data->commandBufferMap.erase(cb_node->commandBuffer);
6172 printCBList(dev_data);
6175 dev_data->dispatch_table.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
6181 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6183 VkResult result = dev_data->dispatch_table.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
6187 dev_data->commandPoolMap[*pCommandPool].createFlags = pCreateInfo->flags;
6188 dev_data->commandPoolMap[*pCommandPool].queueFamilyIndex = pCreateInfo->queueFamilyIndex;
6196 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6197 VkResult result = dev_data->dispatch_table.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
6200 QUERY_POOL_NODE *qp_node = &dev_data->queryPoolMap[*pQueryPool];
6206 static bool PreCallValidateDestroyCommandPool(layer_data *dev_data, VkCommandPool pool, COMMAND_POOL_NODE **cp_state) {
6207 *cp_state = getCommandPoolNode(dev_data, pool);
6208 if (dev_data->instance_data->disabled.destroy_command_pool)
6213 skip |= checkCommandBuffersInFlight(dev_data, *cp_state, "destroy command pool with", VALIDATION_ERROR_00077);
6218 static void PostCallRecordDestroyCommandPool(layer_data *dev_data, VkCommandPool pool, COMMAND_POOL_NODE *cp_state) {
6220 clearCommandBuffersInFlight(dev_data, cp_state);
6222 clear_cmd_buf_and_mem_references(dev_data, cb);
6223 auto cb_node = getCBNode(dev_data, cb);
6227 removeCommandBufferBinding(dev_data, &obj, cb_node);
6230 auto fb_state = getFramebufferState(dev_data, framebuffer);
6234 dev_data->commandBufferMap.erase(cb); // Remove this command buffer
6237 dev_data->commandPoolMap.erase(pool);
6242 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6245 bool skip = PreCallValidateDestroyCommandPool(dev_data, commandPool, &cp_state);
6248 dev_data->dispatch_table.DestroyCommandPool(device, commandPool, pAllocator);
6250 PostCallRecordDestroyCommandPool(dev_data, commandPool, cp_state);
6256 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6260 auto pPool = getCommandPoolNode(dev_data, commandPool);
6261 skip_call |= checkCommandBuffersInFlight(dev_data, pPool, "reset command pool with", VALIDATION_ERROR_00072);
6267 VkResult result = dev_data->dispatch_table.ResetCommandPool(device, commandPool, flags);
6272 clearCommandBuffersInFlight(dev_data, pPool);
6274 resetCB(dev_data, cmdBuffer);
6282 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6286 auto pFence = getFenceNode(dev_data, pFences[i]);
6288 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT,
6298 VkResult result = dev_data->dispatch_table.ResetFences(device, fenceCount, pFences);
6303 auto pFence = getFenceNode(dev_data, pFences[i]);
6322 static bool PreCallValidateDestroyFramebuffer(layer_data *dev_data, VkFramebuffer framebuffer,
6324 *framebuffer_state = getFramebufferState(dev_data, framebuffer);
6326 if (dev_data->instance_data->disabled.destroy_framebuffer)
6330 skip |= ValidateObjectNotInUse(dev_data, *framebuffer_state, *obj_struct, VALIDATION_ERROR_00422);
6335 static void PostCallRecordDestroyFramebuffer(layer_data *dev_data, VkFramebuffer framebuffer, FRAMEBUFFER_STATE *framebuffer_state,
6338 dev_data->frameBufferMap.erase(framebuffer);
6343 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6347 bool skip = PreCallValidateDestroyFramebuffer(dev_data, framebuffer, &framebuffer_state, &obj_struct);
6350 dev_data->dispatch_table.DestroyFramebuffer(device, framebuffer, pAllocator);
6352 PostCallRecordDestroyFramebuffer(dev_data, framebuffer, framebuffer_state, obj_struct);
6356 static bool PreCallValidateDestroyRenderPass(layer_data *dev_data, VkRenderPass render_pass, RENDER_PASS_STATE **rp_state,
6358 *rp_state = getRenderPassState(dev_data, render_pass);
6360 if (dev_data->instance_data->disabled.destroy_renderpass)
6364 skip |= ValidateObjectNotInUse(dev_data, *rp_state, *obj_struct, VALIDATION_ERROR_00393);
6369 static void PostCallRecordDestroyRenderPass(layer_data *dev_data, VkRenderPass render_pass, RENDER_PASS_STATE *rp_state,
6372 dev_data->renderPassMap.erase(render_pass);
6377 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6381 bool skip = PreCallValidateDestroyRenderPass(dev_data, renderPass, &rp_state, &obj_struct);
6384 dev_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
6386 PostCallRecordDestroyRenderPass(dev_data, renderPass, rp_state, obj_struct);
6392 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6398 VkResult result = dev_data->dispatch_table.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
6403 dev_data->bufferMap.insert(std::make_pair(*pBuffer, unique_ptr<BUFFER_NODE>(new BUFFER_NODE(*pBuffer, pCreateInfo))));
6408 static bool PreCallValidateCreateBufferView(layer_data *dev_data, const VkBufferViewCreateInfo *pCreateInfo) {
6410 BUFFER_NODE *buf_node = getBufferNode(dev_data, pCreateInfo->buffer);
6413 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, buf_node, "vkCreateBufferView()");
6416 skip_call |= ValidateBufferUsageFlags(dev_data, buf_node,
6425 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6427 bool skip_call = PreCallValidateCreateBufferView(dev_data, pCreateInfo);
6431 VkResult result = dev_data->dispatch_table.CreateBufferView(device, pCreateInfo, pAllocator, pView);
6434 dev_data->bufferViewMap[*pView] = unique_ptr<BUFFER_VIEW_STATE>(new BUFFER_VIEW_STATE(*pView, pCreateInfo));
6442 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6444 VkResult result = dev_data->dispatch_table.CreateImage(device, pCreateInfo, pAllocator, pImage);
6451 dev_data->imageMap.insert(std::make_pair(*pImage, unique_ptr<IMAGE_STATE>(new IMAGE_STATE(*pImage, pCreateInfo))));
6453 dev_data->imageSubresourceMap[*pImage].push_back(subpair);
6454 dev_data->imageLayoutMap[subpair] = image_state;
6459 static void ResolveRemainingLevelsLayers(layer_data *dev_data, VkImageSubresourceRange *range, VkImage image) {
6462 auto image_state = getImageState(dev_data, image);
6480 static void ResolveRemainingLevelsLayers(layer_data *dev_data, uint32_t *levels, uint32_t *layers, VkImageSubresourceRange range,
6486 auto image_state = getImageState(dev_data, image);
6497 static bool PreCallValidateCreateImageView(layer_data *dev_data, const VkImageViewCreateInfo *pCreateInfo) {
6499 IMAGE_STATE *image_state = getImageState(dev_data, pCreateInfo->image);
6502 dev_data, image_state, VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT |
6507 skip_call |= ValidateMemoryIsBoundToImage(dev_data, image_state, "vkCreateImageView()");
6512 static inline void PostCallRecordCreateImageView(layer_data *dev_data, const VkImageViewCreateInfo *pCreateInfo, VkImageView view) {
6513 dev_data->imageViewMap[view] = unique_ptr<IMAGE_VIEW_STATE>(new IMAGE_VIEW_STATE(view, pCreateInfo));
6514 ResolveRemainingLevelsLayers(dev_data, &dev_data->imageViewMap[view].get()->create_info.subresourceRange, pCreateInfo->image);
6519 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6521 bool skip_call = PreCallValidateCreateImageView(dev_data, pCreateInfo);
6525 VkResult result = dev_data->dispatch_table.CreateImageView(device, pCreateInfo, pAllocator, pView);
6528 PostCallRecordCreateImageView(dev_data, pCreateInfo, *pView);
6537 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6538 VkResult result = dev_data->dispatch_table.CreateFence(device, pCreateInfo, pAllocator, pFence);
6541 auto &fence_node = dev_data->fenceMap[*pFence];
6552 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6553 VkResult result = dev_data->dispatch_table.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
6559 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6560 dev_data->dispatch_table.DestroyPipelineCache(device, pipelineCache, pAllocator);
6565 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6566 VkResult result = dev_data->dispatch_table.GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
6572 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6573 VkResult result = dev_data->dispatch_table.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
6611 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6619 pPipeState[i]->render_pass_ci.initialize(getRenderPassState(dev_data, pCreateInfos[i].renderPass)->createInfo.ptr());
6620 pPipeState[i]->pipeline_layout = *getPipelineLayout(dev_data, pCreateInfos[i].layout);
6622 skip_call |= verifyPipelineCreateState(dev_data, device, pPipeState, i);
6628 dev_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
6632 dev_data->pipelineMap[pPipeState[i]->pipeline] = pPipeState[i];
6654 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6664 dev_data, pCreateInfos[i].layout);
6668 skip_call |= !validate_compute_pipeline(dev_data->report_data, pPipeState[i], &dev_data->enabled_features,
6669 dev_data->shaderModuleMap);
6670 // skip_call |= verifyPipelineCreateState(dev_data, device, pPipeState[i]);
6676 dev_data->dispatch_table.CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pAllocator, pPipelines);
6680 dev_data->pipelineMap[pPipeState[i]->pipeline] = pPipeState[i];
6696 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6697 VkResult result = dev_data->dispatch_table.CreateSampler(device, pCreateInfo, pAllocator, pSampler);
6700 dev_data->samplerMap[*pSampler] = unique_ptr<SAMPLER_STATE>(new SAMPLER_STATE(pSampler, pCreateInfo));
6705 static bool PreCallValidateCreateDescriptorSetLayout(layer_data *dev_data, const VkDescriptorSetLayoutCreateInfo *create_info) {
6706 if (dev_data->instance_data->disabled.create_descriptor_set_layout)
6708 return cvdescriptorset::DescriptorSetLayout::ValidateCreateInfo(dev_data->report_data, create_info);
6711 static void PostCallRecordCreateDescriptorSetLayout(layer_data *dev_data, const VkDescriptorSetLayoutCreateInfo *create_info,
6714 dev_data->descriptorSetLayoutMap[set_layout] = new cvdescriptorset::DescriptorSetLayout(create_info, set_layout);
6720 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6723 bool skip = PreCallValidateCreateDescriptorSetLayout(dev_data, pCreateInfo);
6726 result = dev_data->dispatch_table.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
6729 PostCallRecordCreateDescriptorSetLayout(dev_data, pCreateInfo, *pSetLayout);
6737 static bool validatePushConstantRange(const layer_data *dev_data, const uint32_t offset, const uint32_t size,
6739 if (dev_data->instance_data->disabled.push_constant_range)
6741 uint32_t const maxPushConstantsSize = dev_data->phys_dev_properties.properties.limits.maxPushConstantsSize;
6750 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6755 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6760 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6768 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6774 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6779 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6786 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6791 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6796 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6806 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6811 skip_call |= validatePushConstantRange(dev_data, pCreateInfo->pPushConstantRanges[i].offset,
6814 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6831 log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
6839 VkResult result = dev_data->dispatch_table.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
6842 PIPELINE_LAYOUT_NODE &plNode = dev_data->pipelineLayoutMap[*pPipelineLayout];
6846 plNode.set_layouts[i] = getDescriptorSetLayout(dev_data, pCreateInfo->pSetLayouts[i]);
6859 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6860 VkResult result = dev_data->dispatch_table.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
6862 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
6868 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
6874 dev_data->descriptorPoolMap[*pDescriptorPool] = pNewNode;
6885 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6886 VkResult result = dev_data->dispatch_table.ResetDescriptorPool(device, descriptorPool, flags);
6889 clearDescriptorPool(dev_data, device, descriptorPool, flags);
6896 static bool PreCallValidateAllocateDescriptorSets(layer_data *dev_data, const VkDescriptorSetAllocateInfo *pAllocateInfo,
6898 if (dev_data->instance_data->disabled.allocate_descriptor_sets)
6901 return cvdescriptorset::ValidateAllocateDescriptorSets(dev_data->report_data, pAllocateInfo, dev_data, common_data);
6904 static void PostCallRecordAllocateDescriptorSets(layer_data *dev_data, const VkDescriptorSetAllocateInfo *pAllocateInfo,
6908 cvdescriptorset::PerformAllocateDescriptorSets(pAllocateInfo, pDescriptorSets, common_data, &dev_data->descriptorPoolMap,
6909 &dev_data->setMap, dev_data);
6914 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6917 bool skip_call = PreCallValidateAllocateDescriptorSets(dev_data, pAllocateInfo, &common_data);
6923 VkResult result = dev_data->dispatch_table.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
6927 PostCallRecordAllocateDescriptorSets(dev_data, pAllocateInfo, pDescriptorSets, &common_data);
6933 static bool PreCallValidateFreeDescriptorSets(const layer_data *dev_data, VkDescriptorPool pool, uint32_t count,
6935 if (dev_data->instance_data->disabled.free_descriptor_sets)
6940 skip_call |= validateIdleDescriptorSet(dev_data, descriptor_sets[i], "vkFreeDescriptorSets");
6942 DESCRIPTOR_POOL_STATE *pool_state = getDescriptorPoolState(dev_data, pool);
6945 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT,
6954 static void PostCallRecordFreeDescriptorSets(layer_data *dev_data, VkDescriptorPool pool, uint32_t count,
6956 DESCRIPTOR_POOL_STATE *pool_state = getDescriptorPoolState(dev_data, pool);
6962 auto set_state = dev_data->setMap[descriptor_sets[i]];
6969 freeDescriptorSet(dev_data, set_state);
6976 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
6979 bool skip_call = PreCallValidateFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets);
6984 VkResult result = dev_data->dispatch_table.FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
6987 PostCallRecordFreeDescriptorSets(dev_data, descriptorPool, count, pDescriptorSets);
6996 static bool PreCallValidateUpdateDescriptorSets(layer_data *dev_data, uint32_t descriptorWriteCount,
6999 if (dev_data->instance_data->disabled.update_descriptor_sets)
7008 return cvdescriptorset::ValidateUpdateDescriptorSets(dev_data->report_data, dev_data, descriptorWriteCount, pDescriptorWrites,
7012 static void PostCallRecordUpdateDescriptorSets(layer_data *dev_data, uint32_t descriptorWriteCount,
7015 cvdescriptorset::PerformUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
7023 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
7025 bool skip_call = PreCallValidateUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
7029 dev_data->dispatch_table.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
7033 PostCallRecordUpdateDescriptorSets(dev_data, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount,
7040 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
7041 VkResult result = dev_data->dispatch_table.AllocateCommandBuffers(device, pCreateInfo, pCommandBuffer);
7044 auto pPool = getCommandPoolNode(dev_data, pCreateInfo->commandPool);
7052 dev_data->commandBufferMap[pCommandBuffer[i]] = pCB;
7053 resetCB(dev_data, pCommandBuffer[i]);
7058 printCBList(dev_data);
7065 static void AddFramebufferBinding(layer_data *dev_data, GLOBAL_CB_NODE *cb_state, FRAMEBUFFER_STATE *fb_state) {
7072 AddCommandBufferBindingImageView(dev_data, cb_state, view_state);
7074 auto rp_state = getRenderPassState(dev_data, fb_state->createInfo.renderPass);
7086 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7089 GLOBAL_CB_NODE *cb_node = getCBNode(dev_data, commandBuffer);
7092 if (dev_data->globalInFlightCmdBuffers.count(commandBuffer)) {
7094 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7100 clear_cmd_buf_and_mem_references(dev_data, cb_node);
7106 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7114 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7121 dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7128 auto framebuffer = getFramebufferState(dev_data, pInfo->framebuffer);
7131 !verify_renderpass_compatibility(dev_data, framebuffer->renderPassCreateInfo.ptr(),
7132 getRenderPassState(dev_data, pInfo->renderPass)->createInfo.ptr(),
7136 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
7147 AddFramebufferBinding(dev_data, cb_node, framebuffer);
7152 dev_data->enabled_features.occlusionQueryPrecise == VK_FALSE) &&
7154 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
7164 auto renderPass = getRenderPassState(dev_data, pInfo->renderPass);
7168 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7179 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7186 auto pPool = getCommandPoolNode(dev_data, cmdPool);
7189 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7196 resetCB(dev_data, commandBuffer);
7207 cb_node->activeRenderPass = getRenderPassState(dev_data, cb_node->beginInfo.pInheritanceInfo->renderPass);
7213 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7222 VkResult result = dev_data->dispatch_table.BeginCommandBuffer(commandBuffer, pBeginInfo);
7230 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7232 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7237 skip_call |= insideRenderPass(dev_data, pCB, "vkEndCommandBuffer");
7239 skip_call |= addCmd(dev_data, pCB, CMD_END, "vkEndCommandBuffer()");
7241 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7249 result = dev_data->dispatch_table.EndCommandBuffer(commandBuffer);
7255 printCB(dev_data, commandBuffer);
7267 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7269 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7271 auto pPool = getCommandPoolNode(dev_data, cmdPool);
7273 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7279 skip_call |= checkCommandBufferInFlight(dev_data, pCB, "reset", VALIDATION_ERROR_00092);
7283 VkResult result = dev_data->dispatch_table.ResetCommandBuffer(commandBuffer, flags);
7286 dev_data->globalInFlightCmdBuffers.erase(commandBuffer);
7287 resetCB(dev_data, commandBuffer);
7296 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7298 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7300 skip_call |= addCmd(dev_data, pCB, CMD_BINDPIPELINE, "vkCmdBindPipeline()");
7303 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
7309 PIPELINE_STATE *pPN = getPipelineState(dev_data, pipeline);
7315 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT,
7319 addCommandBufferBinding(&getPipelineState(dev_data, pipeline)->cb_bindings,
7324 dev_data->dispatch_table.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
7330 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7332 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7334 skip_call |= addCmd(dev_data, pCB, CMD_SETVIEWPORTSTATE, "vkCmdSetViewport()");
7339 dev_data->dispatch_table.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
7345 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7347 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7349 skip_call |= addCmd(dev_data, pCB, CMD_SETSCISSORSTATE, "vkCmdSetScissor()");
7354 dev_data->dispatch_table.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
7359 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7361 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7363 skip_call |= addCmd(dev_data, pCB, CMD_SETLINEWIDTHSTATE, "vkCmdSetLineWidth()");
7368 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, (VkDebugReportObjectTypeEXT)0,
7373 skip_call |= verifyLineWidth(dev_data, DRAWSTATE_INVALID_SET, reinterpret_cast<uint64_t &>(commandBuffer), lineWidth);
7378 dev_data->dispatch_table.CmdSetLineWidth(commandBuffer, lineWidth);
7384 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7386 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7388 skip_call |= addCmd(dev_data, pCB, CMD_SETDEPTHBIASSTATE, "vkCmdSetDepthBias()");
7393 dev_data->dispatch_table.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
7398 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7400 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7402 skip_call |= addCmd(dev_data, pCB, CMD_SETBLENDSTATE, "vkCmdSetBlendConstants()");
7407 dev_data->dispatch_table.CmdSetBlendConstants(commandBuffer, blendConstants);
7413 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7415 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7417 skip_call |= addCmd(dev_data, pCB, CMD_SETDEPTHBOUNDSSTATE, "vkCmdSetDepthBounds()");
7422 dev_data->dispatch_table.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
7428 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7430 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7432 skip_call |= addCmd(dev_data, pCB, CMD_SETSTENCILREADMASKSTATE, "vkCmdSetStencilCompareMask()");
7437 dev_data->dispatch_table.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
7443 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7445 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7447 skip_call |= addCmd(dev_data, pCB, CMD_SETSTENCILWRITEMASKSTATE, "vkCmdSetStencilWriteMask()");
7452 dev_data->dispatch_table.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
7458 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7460 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7462 skip_call |= addCmd(dev_data, pCB, CMD_SETSTENCILREFERENCESTATE, "vkCmdSetStencilReference()");
7467 dev_data->dispatch_table.CmdSetStencilReference(commandBuffer, faceMask, reference);
7475 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7477 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7489 dev_data, layout);
7491 cvdescriptorset::DescriptorSet *pSet = getSetNode(dev_data, pDescriptorSets[i]);
7495 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
7500 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT,
7508 if (!verify_set_layout_compatibility(dev_data, pSet, pipeline_layout, i + firstSet, errorString)) {
7509 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
7525 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
7540 dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment) != 0) {
7542 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
7548 dev_data->phys_dev_properties.properties.limits.minUniformBufferOffsetAlignment);
7554 dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment) != 0) {
7556 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
7562 dev_data->phys_dev_properties.properties.limits.minStorageBufferOffsetAlignment);
7577 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
7583 skip_call |= addCmd(dev_data, pCB, CMD_BINDDESCRIPTORSETS, "vkCmdBindDescriptorSets()");
7588 !verify_set_layout_compatibility(dev_data, pCB->lastBound[pipelineBindPoint].boundDescriptorSets[i],
7591 dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
7604 !verify_set_layout_compatibility(dev_data, oldFinalBoundSet, pipeline_layout, lastSetIndex, errorString)) {
7607 log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
7623 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
7630 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindDescriptorSets()");
7635 dev_data->dispatch_table.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, setCount,
7642 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7646 auto buff_node = getBufferNode(dev_data, buffer);
7647 auto cb_node = getCBNode(dev_data, commandBuffer);
7649 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, buff_node, "vkCmdBindIndexBuffer()");
7651 return ValidateBufferMemoryIsValid(dev_data, buff_node, "vkCmdBindIndexBuffer()");
7654 skip_call |= addCmd(dev_data, cb_node, CMD_BINDINDEXBUFFER, "vkCmdBindIndexBuffer()");
7668 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7679 dev_data->dispatch_table.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
7698 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7702 auto cb_node = getCBNode(dev_data, commandBuffer);
7705 auto buff_node = getBufferNode(dev_data, pBuffers[i]);
7707 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, buff_node, "vkCmdBindVertexBuffers()");
7709 return ValidateBufferMemoryIsValid(dev_data, buff_node, "vkCmdBindVertexBuffers()");
7713 addCmd(dev_data, cb_node, CMD_BINDVERTEXBUFFER, "vkCmdBindVertexBuffer()");
7716 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdBindVertexBuffer()");
7720 dev_data->dispatch_table.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
7724 dev_data, GLOBAL_CB_NODE *pCB) {
7728 auto view_state = getImageViewState(dev_data, imageView);
7732 auto image_state = getImageState(dev_data, view_state->create_info.image);
7735 SetImageMemoryValid(dev_data, image_state, true);
7741 auto buff_node = getBufferNode(dev_data, buffer);
7744 SetBufferMemoryValid(dev_data, buff_node, true);
7755 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7757 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7759 skip_call |= addCmd(dev_data, pCB, CMD_DRAW, "vkCmdDraw()");
7761 skip_call |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_GRAPHICS, "vkCmdDraw");
7762 skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
7765 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
7768 skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer);
7772 skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdDraw");
7776 dev_data->dispatch_table.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
7782 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7785 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7787 skip_call |= addCmd(dev_data, pCB, CMD_DRAWINDEXED, "vkCmdDrawIndexed()");
7789 skip_call |= validate_and_update_draw_state(dev_data, pCB, true, VK_PIPELINE_BIND_POINT_GRAPHICS, "vkCmdDrawIndexed");
7790 skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
7792 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
7796 skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer);
7800 skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdDrawIndexed");
7804 dev_data->dispatch_table.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
7809 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7813 auto cb_node = getCBNode(dev_data, commandBuffer);
7814 auto buff_node = getBufferNode(dev_data, buffer);
7816 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, buff_node, "vkCmdDrawIndirect()");
7817 AddCommandBufferBindingBuffer(dev_data, cb_node, buff_node);
7818 skip_call |= addCmd(dev_data, cb_node, CMD_DRAWINDIRECT, "vkCmdDrawIndirect()");
7820 skip_call |= validate_and_update_draw_state(dev_data, cb_node, false, VK_PIPELINE_BIND_POINT_GRAPHICS, "vkCmdDrawIndirect");
7821 skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, cb_node);
7823 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT,
7827 skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer);
7831 skip_call |= outsideRenderPass(dev_data, cb_node, "vkCmdDrawIndirect()");
7837 dev_data->dispatch_table.CmdDrawIndirect(commandBuffer, buffer, offset, count, stride);
7843 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7846 auto cb_node = getCBNode(dev_data, commandBuffer);
7847 auto buff_node = getBufferNode(dev_data, buffer);
7849 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, buff_node, "vkCmdDrawIndexedIndirect()");
7850 AddCommandBufferBindingBuffer(dev_data, cb_node, buff_node);
7851 skip_call |= addCmd(dev_data, cb_node, CMD_DRAWINDEXEDINDIRECT, "vkCmdDrawIndexedIndirect()");
7854 validate_and_update_draw_state(dev_data, cb_node, true, VK_PIPELINE_BIND_POINT_GRAPHICS, "vkCmdDrawIndexedIndirect");
7855 skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, cb_node);
7858 log_msg(dev_data->report_data, VK_DEBUG_REPORT_INFORMATION_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
7861 skip_call |= synchAndPrintDSConfig(dev_data, commandBuffer);
7865 skip_call |= outsideRenderPass(dev_data, cb_node, "vkCmdDrawIndexedIndirect()");
7871 dev_data->dispatch_table.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, count, stride);
7876 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7878 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
7880 skip_call |= validate_and_update_draw_state(dev_data, pCB, false, VK_PIPELINE_BIND_POINT_COMPUTE, "vkCmdDispatch");
7881 skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, pCB);
7882 skip_call |= addCmd(dev_data, pCB, CMD_DISPATCH, "vkCmdDispatch()");
7883 skip_call |= insideRenderPass(dev_data, pCB, "vkCmdDispatch");
7887 dev_data->dispatch_table.CmdDispatch(commandBuffer, x, y, z);
7893 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7896 auto cb_node = getCBNode(dev_data, commandBuffer);
7897 auto buff_node = getBufferNode(dev_data, buffer);
7899 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, buff_node, "vkCmdDispatchIndirect()");
7900 AddCommandBufferBindingBuffer(dev_data, cb_node, buff_node);
7902 validate_and_update_draw_state(dev_data, cb_node, false, VK_PIPELINE_BIND_POINT_COMPUTE, "vkCmdDispatchIndirect");
7903 skip_call |= markStoreImagesAndBuffersAsWritten(dev_data, cb_node);
7904 skip_call |= addCmd(dev_data, cb_node, CMD_DISPATCHINDIRECT, "vkCmdDispatchIndirect()");
7905 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdDispatchIndirect()");
7909 dev_data->dispatch_table.CmdDispatchIndirect(commandBuffer, buffer, offset);
7915 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
7918 auto cb_node = getCBNode(dev_data, commandBuffer);
7919 auto src_buff_node = getBufferNode(dev_data, srcBuffer);
7920 auto dst_buff_node = getBufferNode(dev_data, dstBuffer);
7922 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, src_buff_node, "vkCmdCopyBuffer()");
7923 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, dst_buff_node, "vkCmdCopyBuffer()");
7925 AddCommandBufferBindingBuffer(dev_data, cb_node, src_buff_node);
7926 AddCommandBufferBindingBuffer(dev_data, cb_node, dst_buff_node);
7928 skip_call |= ValidateBufferUsageFlags(dev_data, src_buff_node, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyBuffer()",
7930 skip_call |= ValidateBufferUsageFlags(dev_data, dst_buff_node, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyBuffer()",
7934 return ValidateBufferMemoryIsValid(dev_data, src_buff_node, "vkCmdCopyBuffer()");
7938 SetBufferMemoryValid(dev_data, dst_buff_node, true);
7943 skip_call |= addCmd(dev_data, cb_node, CMD_COPYBUFFER, "vkCmdCopyBuffer()");
7944 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyBuffer()");
7951 dev_data->dispatch_table.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
7954 static bool VerifySourceImageLayout(layer_data *dev_data, GLOBAL_CB_NODE *cb_node, VkImage srcImage,
7969 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
7978 auto image_state = getImageState(dev_data, srcImage);
7981 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
7986 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
7995 static bool VerifyDestImageLayout(layer_data *dev_data, GLOBAL_CB_NODE *cb_node, VkImage destImage,
8009 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT, 0,
8017 auto image_state = getImageState(dev_data, destImage);
8020 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
8025 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8060 static inline VkExtent3D GetScaledItg(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const IMAGE_STATE *img) {
8063 auto pPool = getCommandPoolNode(dev_data, cb_node->createInfo.commandPool);
8065 granularity = dev_data->phys_dev_properties.queue_family_properties[pPool->queueFamilyIndex].minImageTransferGranularity;
8086 static inline bool CheckItgOffset(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const VkOffset3D *offset,
8096 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8106 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8118 static inline bool CheckItgExtent(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const VkExtent3D *extent,
8126 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8143 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8157 static inline bool CheckItgInt(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const uint32_t value,
8161 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8171 static inline bool CheckItgSize(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node, const VkDeviceSize value,
8175 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8186 static inline bool ValidateCopyImageTransferGranularityRequirements(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node,
8190 VkExtent3D granularity = GetScaledItg(dev_data, cb_node, img);
8191 skip |= CheckItgOffset(dev_data, cb_node, ®ion->srcOffset, &granularity, i, function, "srcOffset");
8192 skip |= CheckItgOffset(dev_data, cb_node, ®ion->dstOffset, &granularity, i, function, "dstOffset");
8194 skip |= CheckItgExtent(dev_data, cb_node, ®ion->extent, ®ion->dstOffset, &granularity, &subresource_extent, i, function,
8200 static inline bool ValidateCopyBufferImageTransferGranularityRequirements(layer_data *dev_data, const GLOBAL_CB_NODE *cb_node,
8204 VkExtent3D granularity = GetScaledItg(dev_data, cb_node, img);
8205 skip |= CheckItgSize(dev_data, cb_node, region->bufferOffset, granularity.width, i, function, "bufferOffset");
8206 skip |= CheckItgInt(dev_data, cb_node, region->bufferRowLength, granularity.width, i, function, "bufferRowLength");
8207 skip |= CheckItgInt(dev_data, cb_node, region->bufferImageHeight, granularity.width, i, function, "bufferImageHeight");
8208 skip |= CheckItgOffset(dev_data, cb_node, ®ion->imageOffset, &granularity, i, function, "imageOffset");
8210 skip |= CheckItgExtent(dev_data, cb_node, ®ion->imageExtent, ®ion->imageOffset, &granularity, &subresource_extent, i,
8219 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8222 auto cb_node = getCBNode(dev_data, commandBuffer);
8223 auto src_image_state = getImageState(dev_data, srcImage);
8224 auto dst_image_state = getImageState(dev_data, dstImage);
8226 skip_call |= ValidateMemoryIsBoundToImage(dev_data, src_image_state, "vkCmdCopyImage()");
8227 skip_call |= ValidateMemoryIsBoundToImage(dev_data, dst_image_state, "vkCmdCopyImage()");
8229 AddCommandBufferBindingImage(dev_data, cb_node, src_image_state);
8230 AddCommandBufferBindingImage(dev_data, cb_node, dst_image_state);
8232 skip_call |= ValidateImageUsageFlags(dev_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdCopyImage()",
8234 skip_call |= ValidateImageUsageFlags(dev_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdCopyImage()",
8237 return ValidateImageMemoryIsValid(dev_data, src_image_state, "vkCmdCopyImage()");
8241 SetImageMemoryValid(dev_data, dst_image_state, true);
8246 skip_call |= addCmd(dev_data, cb_node, CMD_COPYIMAGE, "vkCmdCopyImage()");
8247 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyImage()");
8249 skip_call |= VerifySourceImageLayout(dev_data, cb_node, srcImage, pRegions[i].srcSubresource, srcImageLayout);
8250 skip_call |= VerifyDestImageLayout(dev_data, cb_node, dstImage, pRegions[i].dstSubresource, dstImageLayout);
8251 skip_call |= ValidateCopyImageTransferGranularityRequirements(dev_data, cb_node, dst_image_state, &pRegions[i], i,
8259 dev_data->dispatch_table.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
8264 static inline bool ValidateImageSampleCount(layer_data *dev_data, IMAGE_STATE *image_state, VkSampleCountFlagBits sample_count,
8268 skip = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT,
8281 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8284 auto cb_node = getCBNode(dev_data, commandBuffer);
8285 auto src_image_state = getImageState(dev_data, srcImage);
8286 auto dst_image_state = getImageState(dev_data, dstImage);
8288 skip_call |= ValidateImageSampleCount(dev_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): srcImage");
8289 skip_call |= ValidateImageSampleCount(dev_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdBlitImage(): dstImage");
8290 skip_call |= ValidateMemoryIsBoundToImage(dev_data, src_image_state, "vkCmdBlitImage()");
8291 skip_call |= ValidateMemoryIsBoundToImage(dev_data, dst_image_state, "vkCmdBlitImage()");
8293 AddCommandBufferBindingImage(dev_data, cb_node, src_image_state);
8294 AddCommandBufferBindingImage(dev_data, cb_node, dst_image_state);
8296 skip_call |= ValidateImageUsageFlags(dev_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true, "vkCmdBlitImage()",
8298 skip_call |= ValidateImageUsageFlags(dev_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true, "vkCmdBlitImage()",
8301 return ValidateImageMemoryIsValid(dev_data, src_image_state, "vkCmdBlitImage()");
8305 SetImageMemoryValid(dev_data, dst_image_state, true);
8310 skip_call |= addCmd(dev_data, cb_node, CMD_BLITIMAGE, "vkCmdBlitImage()");
8311 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdBlitImage()");
8317 dev_data->dispatch_table.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
8325 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8328 auto cb_node = getCBNode(dev_data, commandBuffer);
8329 auto src_buff_node = getBufferNode(dev_data, srcBuffer);
8330 auto dst_image_state = getImageState(dev_data, dstImage);
8333 ValidateImageSampleCount(dev_data, dst_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyBufferToImage(): dstImage");
8334 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, src_buff_node, "vkCmdCopyBufferToImage()");
8335 skip_call |= ValidateMemoryIsBoundToImage(dev_data, dst_image_state, "vkCmdCopyBufferToImage()");
8336 AddCommandBufferBindingBuffer(dev_data, cb_node, src_buff_node);
8337 AddCommandBufferBindingImage(dev_data, cb_node, dst_image_state);
8338 skip_call |= ValidateBufferUsageFlags(dev_data, src_buff_node, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, true,
8340 skip_call |= ValidateImageUsageFlags(dev_data, dst_image_state, VK_IMAGE_USAGE_TRANSFER_DST_BIT, true,
8343 SetImageMemoryValid(dev_data, dst_image_state, true);
8347 function = [=]() { return ValidateBufferMemoryIsValid(dev_data, src_buff_node, "vkCmdCopyBufferToImage()"); };
8350 skip_call |= addCmd(dev_data, cb_node, CMD_COPYBUFFERTOIMAGE, "vkCmdCopyBufferToImage()");
8351 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyBufferToImage()");
8353 skip_call |= VerifyDestImageLayout(dev_data, cb_node, dstImage, pRegions[i].imageSubresource, dstImageLayout);
8354 skip_call |= ValidateCopyBufferImageTransferGranularityRequirements(dev_data, cb_node, dst_image_state, &pRegions[i], i,
8362 dev_data->dispatch_table.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
8369 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8372 auto cb_node = getCBNode(dev_data, commandBuffer);
8373 auto src_image_state = getImageState(dev_data, srcImage);
8374 auto dst_buff_node = getBufferNode(dev_data, dstBuffer);
8377 ValidateImageSampleCount(dev_data, src_image_state, VK_SAMPLE_COUNT_1_BIT, "vkCmdCopyImageToBuffer(): srcImage");
8378 skip_call |= ValidateMemoryIsBoundToImage(dev_data, src_image_state, "vkCmdCopyImageToBuffer()");
8379 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, dst_buff_node, "vkCmdCopyImageToBuffer()");
8381 AddCommandBufferBindingImage(dev_data, cb_node, src_image_state);
8382 AddCommandBufferBindingBuffer(dev_data, cb_node, dst_buff_node);
8384 skip_call |= ValidateImageUsageFlags(dev_data, src_image_state, VK_IMAGE_USAGE_TRANSFER_SRC_BIT, true,
8386 skip_call |= ValidateBufferUsageFlags(dev_data, dst_buff_node, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
8389 return ValidateImageMemoryIsValid(dev_data, src_image_state, "vkCmdCopyImageToBuffer()");
8393 SetBufferMemoryValid(dev_data, dst_buff_node, true);
8398 skip_call |= addCmd(dev_data, cb_node, CMD_COPYIMAGETOBUFFER, "vkCmdCopyImageToBuffer()");
8399 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyImageToBuffer()");
8401 skip_call |= VerifySourceImageLayout(dev_data, cb_node, srcImage, pRegions[i].imageSubresource, srcImageLayout);
8402 skip_call |= ValidateCopyBufferImageTransferGranularityRequirements(dev_data, cb_node, src_image_state, &pRegions[i], i,
8410 dev_data->dispatch_table.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
8416 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8419 auto cb_node = getCBNode(dev_data, commandBuffer);
8420 auto dst_buff_node = getBufferNode(dev_data, dstBuffer);
8422 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, dst_buff_node, "vkCmdUpdateBuffer()");
8424 AddCommandBufferBindingBuffer(dev_data, cb_node, dst_buff_node);
8426 skip_call |= ValidateBufferUsageFlags(dev_data, dst_buff_node, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
8429 SetBufferMemoryValid(dev_data, dst_buff_node, true);
8434 skip_call |= addCmd(dev_data, cb_node, CMD_UPDATEBUFFER, "vkCmdUpdateBuffer()");
8435 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyUpdateBuffer()");
8441 dev_data->dispatch_table.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
8447 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8450 auto cb_node = getCBNode(dev_data, commandBuffer);
8451 auto dst_buff_node = getBufferNode(dev_data, dstBuffer);
8453 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, dst_buff_node, "vkCmdFillBuffer()");
8455 AddCommandBufferBindingBuffer(dev_data, cb_node, dst_buff_node);
8457 skip_call |= ValidateBufferUsageFlags(dev_data, dst_buff_node, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true, "vkCmdFillBuffer()",
8460 SetBufferMemoryValid(dev_data, dst_buff_node, true);
8465 skip_call |= addCmd(dev_data, cb_node, CMD_FILLBUFFER, "vkCmdFillBuffer()");
8466 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyFillBuffer()");
8472 dev_data->dispatch_table.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
8479 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8481 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8483 skip_call |= addCmd(dev_data, pCB, CMD_CLEARATTACHMENTS, "vkCmdClearAttachments()");
8491 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
8498 skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdClearAttachments()");
8511 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
8518 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
8529 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
8538 dev_data
8545 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8549 auto cb_node = getCBNode(dev_data, commandBuffer);
8550 auto image_state = getImageState(dev_data, image);
8552 skip_call |= ValidateMemoryIsBoundToImage(dev_data, image_state, "vkCmdClearColorImage()");
8553 AddCommandBufferBindingImage(dev_data, cb_node, image_state);
8555 SetImageMemoryValid(dev_data, image_state, true);
8560 skip_call |= addCmd(dev_data, cb_node, CMD_CLEARCOLORIMAGE, "vkCmdClearColorImage()");
8561 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdClearColorImage()");
8567 dev_data->dispatch_table.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
8575 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8579 auto cb_node = getCBNode(dev_data, commandBuffer);
8580 auto image_state = getImageState(dev_data, image);
8582 skip_call |= ValidateMemoryIsBoundToImage(dev_data, image_state, "vkCmdClearDepthStencilImage()");
8583 AddCommandBufferBindingImage(dev_data, cb_node, image_state);
8585 SetImageMemoryValid(dev_data, image_state, true);
8590 skip_call |= addCmd(dev_data, cb_node, CMD_CLEARDEPTHSTENCILIMAGE, "vkCmdClearDepthStencilImage()");
8591 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdClearDepthStencilImage()");
8597 dev_data->dispatch_table.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
8604 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8607 auto cb_node = getCBNode(dev_data, commandBuffer);
8608 auto src_image_state = getImageState(dev_data, srcImage);
8609 auto dst_image_state = getImageState(dev_data, dstImage);
8611 skip_call |= ValidateMemoryIsBoundToImage(dev_data, src_image_state, "vkCmdResolveImage()");
8612 skip_call |= ValidateMemoryIsBoundToImage(dev_data, dst_image_state, "vkCmdResolveImage()");
8614 AddCommandBufferBindingImage(dev_data, cb_node, src_image_state);
8615 AddCommandBufferBindingImage(dev_data, cb_node, dst_image_state);
8617 return ValidateImageMemoryIsValid(dev_data, src_image_state, "vkCmdResolveImage()");
8621 SetImageMemoryValid(dev_data, dst_image_state, true);
8626 skip_call |= addCmd(dev_data, cb_node, CMD_RESOLVEIMAGE, "vkCmdResolveImage()");
8627 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdResolveImage()");
8633 dev_data->dispatch_table.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount,
8638 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8639 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8643 auto queue_data = dev_data->queueMap.find(queue);
8644 if (queue_data != dev_data->queueMap.end()) {
8653 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8655 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8657 skip_call |= addCmd(dev_data, pCB, CMD_SETEVENT, "vkCmdSetEvent()");
8658 skip_call |= insideRenderPass(dev_data, pCB, "vkCmdSetEvent");
8659 auto event_state = getEventNode(dev_data, event);
8675 dev_data->dispatch_table.CmdSetEvent(commandBuffer, event, stageMask);
8681 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
8683 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
8685 skip_call |= addCmd(dev_data, pCB, CMD_RESETEVENT, "vkCmdResetEvent()");
8686 skip_call |= insideRenderPass(dev_data, pCB, "vkCmdResetEvent");
8687 auto event_state = getEventNode(dev_data, event);
8703 dev_data->dispatch_table.CmdResetEvent(commandBuffer, event, stageMask);
8708 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
8709 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer);
8720 ResolveRemainingLevelsLayers(dev_data, &levelCount, &layerCount, mem_barrier->subresourceRange, mem_barrier->image);
8736 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8872 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
8873 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, cmdBuffer);
8876 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8884 auto image_data = getImageState(dev_data, mem_barrier->image);
8892 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8906 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8913 ((src_q_f_index >= dev_data->phys_dev_properties.queue_family_properties.size()) ||
8914 (dst_q_f_index >= dev_data->phys_dev_properties.queue_family_properties.size()))) {
8915 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8922 dst_q_f_index, dev_data->phys_dev_properties.queue_family_properties.size());
8930 ValidateMaskBitsFromLayouts(dev_data, cmdBuffer, mem_barrier->srcAccessMask, mem_barrier->oldLayout, "Source");
8932 ValidateMaskBitsFromLayouts(dev_data, cmdBuffer, mem_barrier->dstAccessMask, mem_barrier->newLayout, "Dest");
8935 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
8940 auto image_data = getImageState(dev_data, mem_barrier->image);
8949 } else if (dev_data->device_extensions.wsi_enabled) {
8950 auto imageswap_data = getSwapchainFromImage(dev_data, mem_barrier->image);
8952 auto swapchain_data = getSwapchainNode(dev_data, imageswap_data);
8966 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8975 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8982 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
8990 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9000 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9011 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9025 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9033 mem_barrier->srcQueueFamilyIndex >= dev_data->phys_dev_properties.queue_family_properties.size()) ||
9035 mem_barrier->dstQueueFamilyIndex >= dev_data->phys_dev_properties.queue_family_properties.size())) {
9036 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9041 dev_data->phys_dev_properties.queue_family_properties.size());
9044 auto buffer_node = getBufferNode(dev_data, mem_barrier->buffer);
9049 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9056 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9071 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
9074 auto queue_data = dev_data->queueMap.find(queue);
9075 if (queue_data == dev_data->queueMap.end())
9081 auto global_event_data = getEventNode(dev_data, event);
9083 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
9095 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9112 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9114 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9118 auto event_state = getEventNode(dev_data, pEvents[i]);
9132 skip_call |= addCmd(dev_data, pCB, CMD_WAITEVENTS, "vkCmdWaitEvents()");
9134 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWaitEvents()");
9143 dev_data->dispatch_table.CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask,
9154 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9156 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9158 skip_call |= addCmd(dev_data, pCB, CMD_PIPELINEBARRIER, "vkCmdPipelineBarrier()");
9166 dev_data->dispatch_table.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount,
9172 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9173 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9177 auto queue_data = dev_data->queueMap.find(queue);
9178 if (queue_data != dev_data->queueMap.end()) {
9187 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9189 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9196 skip_call |= addCmd(dev_data, pCB, CMD_BEGINQUERY, "vkCmdBeginQuery()");
9197 addCommandBufferBinding(&getQueryPoolNode(dev_data, queryPool)->cb_bindings,
9202 dev_data->dispatch_table.CmdBeginQuery(commandBuffer, queryPool, slot, flags);
9207 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9209 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9214 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9223 skip_call |= addCmd(dev_data, pCB, CMD_ENDQUERY, "VkCmdEndQuery()");
9225 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdEndQuery()");
9227 addCommandBufferBinding(&getQueryPoolNode(dev_data, queryPool)->cb_bindings,
9232 dev_data->dispatch_table.CmdEndQuery(commandBuffer, queryPool, slot);
9238 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9240 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9249 skip_call |= addCmd(dev_data, pCB, CMD_RESETQUERYPOOL, "VkCmdResetQueryPool()");
9251 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdResetQueryPool()");
9253 skip_call |= insideRenderPass(dev_data, pCB, "vkCmdQueryPool");
9254 addCommandBufferBinding(&getQueryPoolNode(dev_data, queryPool)->cb_bindings,
9259 dev_data->dispatch_table.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
9264 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(pCB->commandBuffer), layer_data_map);
9265 auto queue_data = dev_data->queueMap.find(queue);
9266 if (queue_data == dev_data->queueMap.end())
9277 auto global_query_data = dev_data->queryToStateMap.find(query);
9278 if (global_query_data != dev_data->queryToStateMap.end()) {
9287 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9300 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9303 auto cb_node = getCBNode(dev_data, commandBuffer);
9304 auto dst_buff_node = getBufferNode(dev_data, dstBuffer);
9306 skip_call |= ValidateMemoryIsBoundToBuffer(dev_data, dst_buff_node, "vkCmdCopyQueryPoolResults()");
9308 AddCommandBufferBindingBuffer(dev_data, cb_node, dst_buff_node);
9310 skip_call |= ValidateBufferUsageFlags(dev_data, dst_buff_node, VK_BUFFER_USAGE_TRANSFER_DST_BIT, true,
9313 SetBufferMemoryValid(dev_data, dst_buff_node, true);
9321 skip_call |= addCmd(dev_data, cb_node, CMD_COPYQUERYPOOLRESULTS, "vkCmdCopyQueryPoolResults()");
9323 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdCopyQueryPoolResults()");
9325 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdCopyQueryPoolResults()");
9326 addCommandBufferBinding(&getQueryPoolNode(dev_data, queryPool)->cb_bindings,
9333 dev_data->dispatch_table.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset,
9341 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9343 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9346 skip_call |= addCmd(dev_data, pCB, CMD_PUSHCONSTANTS, "vkCmdPushConstants()");
9348 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdPushConstants()");
9351 skip_call |= validatePushConstantRange(dev_data, offset, size, "vkCmdPushConstants()");
9353 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9358 auto pipeline_layout = getPipelineLayout(dev_data, layout);
9377 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9416 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9425 dev_data->dispatch_table.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
9431 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
9433 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
9439 skip_call |= addCmd(dev_data, pCB, CMD_WRITETIMESTAMP, "vkCmdWriteTimestamp()");
9441 skip_call |= report_error_no_cb_begin(dev_data, commandBuffer, "vkCmdWriteTimestamp()");
9446 dev_data->dispatch_table.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
9449 static bool MatchUsage(layer_data *dev_data, uint32_t count, const VkAttachmentReference *attachments,
9458 auto view_state = getImageViewState(dev_data, *image_view);
9460 const VkImageCreateInfo *ici = &getImageState(dev_data, view_state->create_info.image)->createInfo;
9463 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
9486 static bool ValidateFramebufferCreateInfo(layer_data *dev_data, const VkFramebufferCreateInfo *pCreateInfo) {
9489 auto rp_state = getRenderPassState(dev_data, pCreateInfo->renderPass);
9494 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
9503 auto view_state = getImageViewState(dev_data, image_views[i]);
9507 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
9515 const VkImageCreateInfo *ici = &getImageState(dev_data, ivci.image)->createInfo;
9518 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
9527 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
9539 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
9557 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
9573 skip_call |= MatchUsage(dev_data, rpci->pSubpasses[subpass].inputAttachmentCount,
9576 skip_call |= MatchUsage(dev_data, rpci->pSubpasses[subpass].colorAttachmentCount,
9580 skip_call |= MatchUsage(dev_data, 1, rpci->pSubpasses[subpass].pDepthStencilAttachment, pCreateInfo,
9586 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
9592 if ((pCreateInfo->height > dev_data->phys_dev_properties.properties.limits.maxFramebufferHeight) ||
9593 (pCreateInfo->width > dev_data->phys_dev_properties.properties.limits.maxFramebufferWidth) ||
9594 (pCreateInfo->layers > dev_data->phys_dev_properties.properties.limits.maxFramebufferLayers)) {
9595 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0, __LINE__,
9602 pCreateInfo->width, dev_data->phys_dev_properties.properties.limits.maxFramebufferWidth,
9603 pCreateInfo->height, dev_data->phys_dev_properties.properties.limits.maxFramebufferHeight,
9604 pCreateInfo->layers, dev_data->phys_dev_properties.properties.limits.maxFramebufferLayers);
9612 static bool PreCallValidateCreateFramebuffer(layer_data *dev_data, const VkFramebufferCreateInfo *pCreateInfo) {
9615 skip_call |= ValidateFramebufferCreateInfo(dev_data, pCreateInfo);
9620 static void PostCallRecordCreateFramebuffer(layer_data *dev_data, const VkFramebufferCreateInfo *pCreateInfo, VkFramebuffer fb) {
9623 new FRAMEBUFFER_STATE(fb, pCreateInfo, dev_data->renderPassMap[pCreateInfo->renderPass]->createInfo.ptr()));
9627 auto view_state = getImageViewState(dev_data, view);
9632 fb_info.mem = getImageState(dev_data, view_state->create_info.image)->binding.mem;
9637 dev_data->frameBufferMap[fb] = std::move(fb_state);
9643 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
9645 bool skip_call = PreCallValidateCreateFramebuffer(dev_data, pCreateInfo);
9651 VkResult result = dev_data->dispatch_table.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
9655 PostCallRecordCreateFramebuffer(dev_data, pCreateInfo, *pFramebuffer);
9680 static bool CheckDependencyExists(const layer_data *dev_data, const int subpass, const std::vector<uint32_t> &dependent_subpasses,
9696 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
9707 static bool CheckPreserved(const layer_data *dev_data, const VkRenderPassCreateInfo *pCreateInfo, const int index,
9723 result |= CheckPreserved(dev_data, pCreateInfo, elem, attachment, subpass_to_node, depth + 1, skip_call);
9737 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9755 static bool ValidateDependencies(const layer_data *dev_data, FRAMEBUFFER_STATE const *framebuffer,
9774 auto view_state_i = getImageViewState(dev_data, viewi);
9775 auto view_state_j = getImageViewState(dev_data, viewj);
9786 auto image_data_i = getImageState(dev_data, view_ci_i.image);
9787 auto image_data_j = getImageState(dev_data, view_ci_j.image);
9804 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9811 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9851 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
9865 CheckDependencyExists(dev_data, i, output_attachment_to_subpass[attachment], subpass_to_node, skip_call);
9872 CheckDependencyExists(dev_data, i, output_attachment_to_subpass[attachment], subpass_to_node, skip_call);
9873 CheckDependencyExists(dev_data, i, input_attachment_to_subpass[attachment], subpass_to_node, skip_call);
9877 CheckDependencyExists(dev_data, i, output_attachment_to_subpass[attachment], subpass_to_node, skip_call);
9878 CheckDependencyExists(dev_data, i, input_attachment_to_subpass[attachment], subpass_to_node, skip_call);
9886 CheckPreserved(dev_data, pCreateInfo, i, subpass.pInputAttachments[j].attachment, subpass_to_node, 0, skip_call);
9911 static bool ValidateLayouts(const layer_data *dev_data, VkDevice device, const VkRenderPassCreateInfo *pCreateInfo) {
9932 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
9938 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
9945 skip |= ValidateLayoutVsAttachmentDescription(dev_data->report_data, subpass.pColorAttachments[j].layout,
9962 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
9969 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 0,
9978 skip |= ValidateLayoutVsAttachmentDescription(dev_data->report_data, subpass.pDepthStencilAttachment->layout,
9998 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT,
10005 skip |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10012 skip |= ValidateLayoutVsAttachmentDescription(dev_data->report_data, subpass.pInputAttachments[j].layout,
10021 static bool CreatePassDAG(const layer_data *dev_data, VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
10033 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10042 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10059 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
10070 log_msg(dev_data->report_data, result == SPV_WARNING ? VK_DEBUG_REPORT_WARNING_BIT_EXT : VK_DEBUG_REPORT_ERROR_BIT_EXT,
10081 VkResult res = dev_data->dispatch_table.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
10085 dev_data->shaderModuleMap[*pShaderModule] = unique_ptr<shader_module>(new shader_module(pCreateInfo));
10090 static bool ValidateAttachmentIndex(layer_data *dev_data, uint32_t attachment, uint32_t attachment_count, const char *type) {
10093 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10105 static bool ValidateRenderpassAttachmentUsage(layer_data *dev_data, const VkRenderPassCreateInfo *pCreateInfo) {
10111 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10118 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
10122 skip_call |= ValidateAttachmentIndex(dev_data, attachment, pCreateInfo->attachmentCount, "Preserve");
10136 skip_call |= ValidateAttachmentIndex(dev_data, attachment, pCreateInfo->attachmentCount, "Resolve");
10140 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
10148 skip_call |= ValidateAttachmentIndex(dev_data, attachment, pCreateInfo->attachmentCount, "Color");
10155 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
10166 skip_call |= ValidateAttachmentIndex(dev_data, attachment, pCreateInfo->attachmentCount, "Depth stencil");
10175 skip_call |= ValidateAttachmentIndex(dev_data, attachment, pCreateInfo->attachmentCount, "Input");
10179 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VkDebugReportObjectTypeEXT(0), 0,
10192 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
10196 skip_call |= ValidateLayouts(dev_data, device, pCreateInfo);
10199 skip_call |= ValidateRenderpassAttachmentUsage(dev_data, pCreateInfo);
10206 VkResult result = dev_data->dispatch_table.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
10213 skip_call |= CreatePassDAG(dev_data, device, pCreateInfo, subpass_to_node, has_self_dependency);
10248 dev_data->renderPassMap[*pRenderPass] = std::move(render_pass);
10253 static bool VerifyFramebufferAndRenderPassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin) {
10255 auto const pRenderPassInfo = getRenderPassState(dev_data, pRenderPassBegin->renderPass)->createInfo.ptr();
10256 auto const & framebufferInfo = dev_data->frameBufferMap[pRenderPassBegin->framebuffer]->createInfo;
10258 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10264 auto view_state = getImageViewState(dev_data, image_view);
10284 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10299 static void TransitionAttachmentRefLayout(layer_data *dev_data, GLOBAL_CB_NODE *pCB, FRAMEBUFFER_STATE *pFramebuffer,
10303 SetLayout(dev_data, pCB, image_view, ref.layout);
10307 static void TransitionSubpassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin,
10309 auto renderPass = getRenderPassState(dev_data, pRenderPassBegin->renderPass);
10313 auto framebuffer = getFramebufferState(dev_data, pRenderPassBegin->framebuffer);
10319 TransitionAttachmentRefLayout(dev_data, pCB, framebuffer, subpass.pInputAttachments[j]);
10322 TransitionAttachmentRefLayout(dev_data, pCB, framebuffer, subpass.pColorAttachments[j]);
10325 TransitionAttachmentRefLayout(dev_data, pCB, framebuffer, *subpass.pDepthStencilAttachment);
10329 static bool validatePrimaryCommandBuffer(const layer_data *dev_data, const GLOBAL_CB_NODE *pCB, const std::string &cmd_name) {
10332 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10339 static void TransitionFinalSubpassLayouts(layer_data *dev_data, GLOBAL_CB_NODE *pCB, const VkRenderPassBeginInfo *pRenderPassBegin) {
10340 auto renderPass = getRenderPassState(dev_data, pRenderPassBegin->renderPass);
10345 auto framebuffer = getFramebufferState(dev_data, pRenderPassBegin->framebuffer);
10351 SetLayout(dev_data, pCB, image_view, pRenderPassInfo->pAttachments[i].finalLayout);
10355 static bool VerifyRenderAreaBounds(const layer_data *dev_data, const VkRenderPassBeginInfo *pRenderPassBegin) {
10358 &getFramebufferState(dev_data, pRenderPassBegin->framebuffer)->createInfo;
10364 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10392 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
10394 GLOBAL_CB_NODE *cb_node = getCBNode(dev_data, commandBuffer);
10395 auto renderPass = pRenderPassBegin ? getRenderPassState(dev_data, pRenderPassBegin->renderPass) : nullptr;
10396 auto framebuffer = pRenderPassBegin ? getFramebufferState(dev_data, pRenderPassBegin->framebuffer) : nullptr;
10409 SetImageMemoryValid(dev_data, getImageState(dev_data, fb_info.image), true);
10417 SetImageMemoryValid(dev_data, getImageState(dev_data, fb_info.image), false);
10425 return ValidateImageMemoryIsValid(dev_data, getImageState(dev_data, fb_info.image),
10432 return ValidateImageMemoryIsValid(dev_data, getImageState(dev_data, fb_info.image),
10440 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT,
10451 skip_call |= VerifyRenderAreaBounds(dev_data, pRenderPassBegin);
10452 skip_call |= VerifyFramebufferAndRenderPassLayouts(dev_data, cb_node, pRenderPassBegin);
10453 skip_call |= insideRenderPass(dev_data, cb_node, "vkCmdBeginRenderPass");
10454 skip_call |= ValidateDependencies(dev_data, framebuffer, renderPass);
10455 skip_call |= validatePrimaryCommandBuffer(dev_data, cb_node, "vkCmdBeginRenderPass");
10456 skip_call |= addCmd(dev_data, cb_node, CMD_BEGINRENDERPASS, "vkCmdBeginRenderPass()");
10464 AddFramebufferBinding(dev_data, cb_node, framebuffer);
10466 TransitionSubpassLayouts(dev_data, cb_node, &cb_node->activeRenderPassBeginInfo, cb_node->activeSubpass);
10469 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10475 dev_data->dispatch_table.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
10481 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
10483 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
10485 skip_call |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdNextSubpass");
10486 dev_data, pCB, CMD_NEXTSUBPASS, "vkCmdNextSubpass()");
10487 skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdNextSubpass");
10492 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10502 dev_data->dispatch_table.CmdNextSubpass(commandBuffer, contents);
10508 TransitionSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo, pCB->activeSubpass);
10514 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
10516 auto pCB = getCBNode(dev_data, commandBuffer);
10519 auto framebuffer = getFramebufferState(dev_data, pCB->activeFramebuffer);
10523 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10534 SetImageMemoryValid(dev_data, getImageState(dev_data, fb_info.image), true);
10542 SetImageMemoryValid(dev_data, getImageState(dev_data, fb_info.image), false);
10549 skip_call |= outsideRenderPass(dev_data, pCB, "vkCmdEndRenderpass");
10550 skip_call |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdEndRenderPass");
10551 skip_call |= addCmd(dev_data, pCB, CMD_ENDRENDERPASS, "vkCmdEndRenderPass()");
10558 dev_data->dispatch_table.CmdEndRenderPass(commandBuffer);
10562 TransitionFinalSubpassLayouts(dev_data, pCB, &pCB->activeRenderPassBeginInfo);
10569 static bool logInvalidAttachmentMessage(layer_data *dev_data, VkCommandBuffer secondaryBuffer, uint32_t primaryAttach,
10571 return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10579 static bool validateAttachmentCompatibility(layer_data *dev_data, VkCommandBuffer primaryBuffer,
10594 skip_call |= logInvalidAttachmentMessage(dev_data, secondaryBuffer, primaryAttach, secondaryAttach,
10599 skip_call |= logInvalidAttachmentMessage(dev_data, secondaryBuffer, primaryAttach, secondaryAttach,
10605 logInvalidAttachmentMessage(dev_data, secondaryBuffer, primaryAttach, secondaryAttach, "They have different formats.");
10609 logInvalidAttachmentMessage(dev_data, secondaryBuffer, primaryAttach, secondaryAttach, "They have different samples.");
10613 logInvalidAttachmentMessage(dev_data, secondaryBuffer, primaryAttach, secondaryAttach, "They have different flags.");
10618 static bool validateSubpassCompatibility(layer_data *dev_data, VkCommandBuffer primaryBuffer,
10633 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPassCI, primary_input_attach, secondaryBuffer,
10645 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPassCI, primary_color_attach, secondaryBuffer,
10654 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPassCI, primary_resolve_attach,
10664 skip_call |= validateAttachmentCompatibility(dev_data, primaryBuffer, primaryPassCI, primary_depthstencil_attach,
10672 static bool validateRenderPassCompatibility(layer_data *dev_data, VkCommandBuffer primaryBuffer,
10678 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10687 skip_call |= validateSubpassCompatibility(dev_data, primaryBuffer, primaryPassCI, secondaryBuffer, secondaryPassCI, i,
10694 static bool validateFramebuffer(layer_data *dev_data, VkCommandBuffer primaryBuffer, const GLOBAL_CB_NODE *pCB,
10704 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10712 auto fb = getFramebufferState(dev_data, secondary_fb);
10715 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10721 auto cb_renderpass = getRenderPassState(dev_data, pSubCB->beginInfo.pInheritanceInfo->renderPass);
10723 skip_call |= validateRenderPassCompatibility(dev_data, secondaryBuffer, fb->renderPassCreateInfo.ptr(), secondaryBuffer,
10730 static bool validateSecondaryCommandBufferState(layer_data *dev_data, GLOBAL_CB_NODE *pCB, GLOBAL_CB_NODE *pSubCB) {
10734 auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool);
10735 if (queryPoolData != dev_data->queryPoolMap.end()) {
10741 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10753 auto queryPoolData = dev_data->queryPoolMap.find(queryObject.pool);
10754 if (queryPoolData != dev_data
10756 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10766 auto primary_pool = getCommandPoolNode(dev_data, pCB->createInfo.commandPool);
10767 auto secondary_pool = getCommandPoolNode(dev_data, pSubCB->createInfo.commandPool);
10769 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10783 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(commandBuffer), layer_data_map);
10785 GLOBAL_CB_NODE *pCB = getCBNode(dev_data, commandBuffer);
10789 pSubCB = getCBNode(dev_data, pCommandBuffers[i]);
10792 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
10797 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
10803 auto secondary_rp_state = getRenderPassState(dev_data, pSubCB->beginInfo.pInheritanceInfo->renderPass);
10806 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10815 validateRenderPassCompatibility(dev_data, commandBuffer, pCB->activeRenderPass->createInfo.ptr(),
10819 skip_call |= validateFramebuffer(dev_data, commandBuffer, pCB, pCommandBuffers[i], pSubCB);
10824 !verify_renderpass_compatibility(dev_data, pCB->activeRenderPass->createInfo.ptr(),
10827 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10836 skip_call |= validateSecondaryCommandBufferState(dev_data, pCB, pSubCB);
10837 skip_call |= validateCommandBufferState(dev_data, pSubCB, "vkCmdExecuteCommands()");
10841 if (dev_data->globalInFlightCmdBuffers.find(pSubCB->commandBuffer) != dev_data->globalInFlightCmdBuffers.end()) {
10843 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10852 dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10862 if (!pCB->activeQueries.empty() && !dev_data->enabled_features.inheritedQueries) {
10864 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT,
10874 dev_data->globalInFlightCmdBuffers.insert(pSubCB->commandBuffer);
10879 skip_call |= validatePrimaryCommandBuffer(dev_data, pCB, "vkCmdExecuteComands");
10880 skip_call |= addCmd(dev_data, pCB, CMD_EXECUTECOMMANDS, "vkCmdExecuteComands()");
10884 dev_data->dispatch_table.CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
10891 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
10898 if (rangesIntersect(dev_data, &img_it->second, offset, end_offset)) {
10900 if (FindLayouts(dev_data, VkImage(image_handle), layouts)) {
10904 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
10919 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
10924 DEVICE_MEM_INFO *mem_info = getMemObjInfo(dev_data, mem);
10931 SetMemRangesValid(dev_data, mem_info, offset, end_offset);
10932 if ((dev_data->phys_dev_mem_props.memoryTypes[mem_info->alloc_info.memoryTypeIndex].propertyFlags &
10935 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
10940 skip_call |= ValidateMapMemRange(dev_data, mem, offset, size);
10944 result = dev_data->dispatch_table.MapMemory(device, mem, offset, size, flags, ppData);
10948 storeMemRanges(dev_data, mem, offset, size);
10949 initializeAndTrackMemory(dev_data, mem, offset, size, ppData);
10957 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
10961 skip_call |= deleteMemRanges(dev_data, mem);
10964 dev_data->dispatch_table.UnmapMemory(device, mem);
10968 static bool validateMemoryIsMapped(layer_data *dev_data, const char *funcName, uint32_t memRangeCount,
10972 auto mem_info = getMemObjInfo(dev_data, pMemRanges[i].memory);
10976 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
10987 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
11000 static bool ValidateAndCopyNoncoherentMemoryToDriver(layer_data *dev_data, uint32_t memRangeCount,
11004 auto mem_info = getMemObjInfo(dev_data, pMemRanges[i].memory);
11014 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
11022 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
11034 static void CopyNoncoherentMemoryFromDriver(layer_data *dev_data, uint32_t memory_range_count,
11037 auto mem_info = getMemObjInfo(dev_data, mem_ranges[i].memory);
11052 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11055 skip_call |= ValidateAndCopyNoncoherentMemoryToDriver(dev_data, memRangeCount, pMemRanges);
11056 skip_call |= validateMemoryIsMapped(dev_data, "vkFlushMappedMemoryRanges", memRangeCount, pMemRanges);
11059 result = dev_data->dispatch_table.FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
11068 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11071 skip_call |= validateMemoryIsMapped(dev_data, "vkInvalidateMappedMemoryRanges", memRangeCount, pMemRanges);
11074 result = dev_data->dispatch_table.InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
11076 CopyNoncoherentMemoryFromDriver(dev_data, memRangeCount, pMemRanges);
11082 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11086 auto image_state = getImageState(dev_data, image);
11090 skip_call = SetMemBinding(dev_data, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory");
11093 dev_data->dispatch_table.GetImageMemoryRequirements(device, image, &memRequirements);
11097 auto mem_info = getMemObjInfo(dev_data, mem);
11099 skip_call |= InsertImageMemoryRange(dev_data, image, mem_info, memoryOffset, memRequirements,
11101 skip_call |= ValidateMemoryTypes(dev_data, mem_info, memRequirements.memoryTypeBits, "vkBindImageMemory");
11104 print_mem_list(dev_data);
11107 result = dev_data->dispatch_table.BindImageMemory(device, image, mem, memoryOffset);
11115 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
11126 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11128 auto event_state = getEventNode(dev_data, event);
11133 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT,
11143 for (auto queue_data : dev_data->queueMap) {
11150 result = dev_data->dispatch_table.SetEvent(device, event);
11156 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
11160 auto pFence = getFenceNode(dev_data, fence);
11161 auto pQueue = getQueueNode(dev_data, queue);
11164 skip_call |= ValidateFenceForSubmit(dev_data, pFence);
11176 if (SetSparseMemBinding(dev_data, {sparse_binding.memory, sparse_binding.memoryOffset, sparse_binding.size},
11185 if (SetSparseMemBinding(dev_data, {sparse_binding.memory, sparse_binding.memoryOffset, sparse_binding.size},
11196 if (SetSparseMemBinding(dev_data, {sparse_binding.memory, sparse_binding.memoryOffset, size},
11207 auto pSemaphore = getSemaphoreNode(dev_data, semaphore);
11218 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
11228 auto pSemaphore = getSemaphoreNode(dev_data, semaphore);
11232 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
11262 print_mem_list(dev_data);
11266 return dev_data->dispatch_table.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
11273 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11274 VkResult result = dev_data->dispatch_table.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
11277 SEMAPHORE_NODE* sNode = &dev_data->semaphoreMap[*pSemaphore];
11287 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11288 VkResult result = dev_data->dispatch_table.CreateEvent(device, pCreateInfo, pAllocator, pEvent);
11291 dev_data->eventMap[*pEvent].needsSignaled = false;
11292 dev_data->eventMap[*pEvent].write_in_use = 0;
11293 dev_data->eventMap[*pEvent].stageMask = VkPipelineStageFlags(0);
11298 static bool PreCallValidateCreateSwapchainKHR(layer_data *dev_data, VkSwapchainCreateInfoKHR const *pCreateInfo,
11303 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
11304 reinterpret_cast<uint64_t>(dev_data->device), __LINE__, DRAWSTATE_SWAPCHAIN_ALREADY_EXISTS, "DS",
11309 if (log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
11321 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11322 auto surface_state = getSurfaceState(dev_data->instance_data, pCreateInfo->surface);
11323 auto old_swapchain_state = getSwapchainNode(dev_data, pCreateInfo->oldSwapchain);
11325 if (PreCallValidateCreateSwapchainKHR(dev_data, pCreateInfo, surface_state, old_swapchain_state))
11328 VkResult result = dev_data->dispatch_table.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
11334 dev_data->device_extensions.swapchainMap[*pSwapchain] = std::move(swapchain_state);
11347 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11351 auto swapchain_data = getSwapchainNode(dev_data, swapchain);
11355 auto image_sub = dev_data->imageSubresourceMap.find(swapchain_image);
11356 if (image_sub != dev_data->imageSubresourceMap.end()) {
11358 auto image_item = dev_data->imageLayoutMap.find(imgsubpair);
11359 if (image_item != dev_data->imageLayoutMap.end()) {
11360 dev_data->imageLayoutMap.erase(image_item);
11363 dev_data->imageSubresourceMap.erase(image_sub);
11366 ClearMemoryObjectBindings(dev_data, (uint64_t)swapchain_image, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT);
11367 dev_data->imageMap.erase(swapchain_image);
11371 auto surface_state = getSurfaceState(dev_data->instance_data, swapchain_data->createInfo.surface);
11379 dev_data->device_extensions.swapchainMap.erase(swapchain);
11383 dev_data->dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
11388 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11389 VkResult result = dev_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
11397 auto swapchain_node = getSwapchainNode(dev_data, swapchain);
11404 log_msg(dev_data->report_data, VK_DEBUG_REPORT_WARNING_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
11425 dev_data->imageMap[pSwapchainImages[i]] = unique_ptr<IMAGE_STATE>(new IMAGE_STATE(pSwapchainImages[i], &image_ci));
11426 auto &image_state = dev_data->imageMap[pSwapchainImages[i]];
11431 dev_data->imageSubresourceMap[pSwapchainImages[i]].push_back(subpair);
11432 dev_data->imageLayoutMap[subpair] = image_layout_node;
11433 dev_data->device_extensions.imageToSwapchainMap[pSwapchainImages[i]] = swapchain;
11440 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
11445 auto pSemaphore = getSemaphoreNode(dev_data, pPresentInfo->pWaitSemaphores[i]);
11448 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT,
11456 auto swapchain_data = getSwapchainNode(dev_data, pPresentInfo->pSwapchains[i]);
11459 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
11466 auto image_state = getImageState(dev_data, image);
11467 skip_call |= ValidateImageMemoryIsValid(dev_data, image_state, "vkQueuePresentKHR()");
11470 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
11477 if (FindLayouts(dev_data, image, layouts)) {
11481 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT,
11497 VkResult result = dev_data->dispatch_table.QueuePresentKHR(queue, pPresentInfo);
11503 auto pSemaphore = getSemaphoreNode(dev_data, pPresentInfo->pWaitSemaphores[i]);
11520 auto swapchain_data = getSwapchainNode(dev_data, pPresentInfo->pSwapchains[i]);
11522 auto image_state = getImageState(dev_data, image);
11537 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11540 dev_data->dispatch_table.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
11546 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
11552 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT,
11558 auto pSemaphore = getSemaphoreNode(dev_data, semaphore);
11560 skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT,
11565 auto pFence = getFenceNode(dev_data, fence);
11567 skip_call |= ValidateFenceForSubmit(dev_data, pFence);
11574 VkResult result = dev_data->dispatch_table.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex);
11590 auto swapchain_data = getSwapchainNode(dev_data, swapchain);
11592 auto image_state = getImageState(dev_data, image);
11868 layer_data *dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
11870 auto &table = dev_data->dispatch_table;
12071 layer_data *dev_data = nullptr;
12074 dev_data = get_my_data_ptr(get_dispatch_key(dev), layer_data_map);
12075 if (!dev_data->device_extensions.wsi_enabled)
12084 if (dev_data) {
12085 if (!dev_data->device_extensions.wsi_display_swapchain_enabled)
