layers: Merge binding maps into image and buffer maps

mem_tracker layer had specific maps to track memory binding for images
and buffers. This change merges the data from those maps into IMAGE_NODE
and BUFFER_NODE respectively and eliminates the binding maps.

1 files changed, 122 insertions, 219 deletions

diff --git a/layers/core_validation.cpp b/layers/core_validation.cpp
index c3768da6..ad922947 100644
--- a/layers/core_validation.cpp
+++ b/layers/core_validation.cpp
@@ -37,19 +37,19 @@
 // Turn on mem_tracker merged code
 #define MTMERGESOURCE 1
 
+#include <SPIRV/spirv.hpp>
+#include <algorithm>
+#include <assert.h>
+#include <iostream>
+#include <list>
+#include <map>
+#include <set>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
+#include <string>
 #include <unordered_map>
 #include <unordered_set>
-#include <map>
-#include <string>
-#include <iostream>
-#include <algorithm>
-#include <list>
-#include <SPIRV/spirv.hpp>
-#include <set>
 
 #include "vk_loader_platform.h"
 #include "vk_dispatch_table_helper.h"
@@ -105,16 +105,9 @@ struct layer_data {
     std::vector<VkDebugReportCallbackEXT> logging_callback;
     VkLayerDispatchTable *device_dispatch_table;
     VkLayerInstanceDispatchTable *instance_dispatch_table;
-#if MTMERGESOURCE
-// MTMERGESOURCE - stuff pulled directly from MT
-    uint64_t currentFenceId;
-    // Maps for tracking key structs related to mem_tracker state
-    // Images and Buffers are 2 objects that can have memory bound to them so they get special treatment
-    unordered_map<uint64_t, MT_OBJ_BINDING_INFO> imageBindingMap;
-    unordered_map<uint64_t, MT_OBJ_BINDING_INFO> bufferBindingMap;
-// MTMERGESOURCE - End of MT stuff
-#endif
+
     devExts device_extensions;
+    uint64_t currentFenceId;
     unordered_set<VkQueue> queues;  // all queues under given device
     // Global set of all cmdBuffers that are inFlight on this device
     unordered_set<VkCommandBuffer> globalInFlightCmdBuffers;
@@ -152,11 +145,8 @@ struct layer_data {
     PHYS_DEV_PROPERTIES_NODE physDevProperties;
 // MTMERGESOURCE - added a couple of fields to constructor initializer
     layer_data()
-        : report_data(nullptr), device_dispatch_table(nullptr), instance_dispatch_table(nullptr),
-#if MTMERGESOURCE
-        currentFenceId(1),
-#endif
-        device_extensions(){};
+        : report_data(nullptr), device_dispatch_table(nullptr), instance_dispatch_table(nullptr), device_extensions(),
+          currentFenceId(1){};
 };
 
 static const VkLayerProperties cv_global_layers[] = {{
@@ -260,25 +250,24 @@ static void clear_cmd_buf_and_mem_references(layer_data *my_data, const VkComman
 
 #define MAX_BINDING 0xFFFFFFFF
 
-static MT_OBJ_BINDING_INFO *get_object_binding_info(layer_data *my_data, uint64_t handle, VkDebugReportObjectTypeEXT type) {
-    MT_OBJ_BINDING_INFO *retValue = NULL;
+static VkDeviceMemory *get_object_mem_binding(layer_data *my_data, uint64_t handle, VkDebugReportObjectTypeEXT type) {
     switch (type) {
     case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: {
-        auto it = my_data->imageBindingMap.find(handle);
-        if (it != my_data->imageBindingMap.end())
-            return &(*it).second;
+        auto it = my_data->imageMap.find(VkImage(handle));
+        if (it != my_data->imageMap.end())
+            return &(*it).second.mem;
         break;
     }
     case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: {
-        auto it = my_data->bufferBindingMap.find(handle);
-        if (it != my_data->bufferBindingMap.end())
-            return &(*it).second;
+        auto it = my_data->bufferMap.find(VkBuffer(handle));
+        if (it != my_data->bufferMap.end())
+            return &(*it).second.mem;
         break;
     }
     default:
         break;
     }
-    return retValue;
+    return nullptr;
 }
 // MTMERGESOURCE - end section
 #endif
@@ -301,59 +290,6 @@ static void delete_cmd_buf_info(layer_data *my_data, VkCommandPool commandPool,
     my_data->commandBufferMap.erase(cb);
 }
 
-static void add_object_binding_info(layer_data *my_data, const uint64_t handle, const VkDebugReportObjectTypeEXT type,
-                                    const VkDeviceMemory mem) {
-    switch (type) {
-    // Buffers and images are unique as their CreateInfo is in container struct
-    case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: {
-        auto pCI = &my_data->bufferBindingMap[handle];
-        pCI->mem = mem;
-        break;
-    }
-    case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: {
-        auto pCI = &my_data->imageBindingMap[handle];
-        pCI->mem = mem;
-        break;
-    }
-    default:
-        break;
-    }
-}
-
-static void add_object_create_info(layer_data *my_data, const uint64_t handle, const VkDebugReportObjectTypeEXT type,
-                                   const void *pCreateInfo) {
-    // TODO : For any CreateInfo struct that has ptrs, need to deep copy them and appropriately clean up on Destroy
-    switch (type) {
-    // Buffers and images are unique as their CreateInfo is in container struct
-    case VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: {
-        auto pCI = &my_data->bufferBindingMap[handle];
-        memset(pCI, 0, sizeof(MT_OBJ_BINDING_INFO));
-        memcpy(&pCI->create_info.buffer, pCreateInfo, sizeof(VkBufferCreateInfo));
-        break;
-    }
-    case VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: {
-        auto pCI = &my_data->imageBindingMap[handle];
-        memset(pCI, 0, sizeof(MT_OBJ_BINDING_INFO));
-        memcpy(&pCI->create_info.image, pCreateInfo, sizeof(VkImageCreateInfo));
-        break;
-    }
-    // Swap Chain is very unique, use my_data->imageBindingMap, but copy in
-    // SwapChainCreatInfo's usage flags and set the mem value to a unique key. These is used by
-    // vkCreateImageView and internal mem_tracker routines to distinguish swap chain images
-    case VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: {
-        auto pCI = &my_data->imageBindingMap[handle];
-        memset(pCI, 0, sizeof(MT_OBJ_BINDING_INFO));
-        pCI->mem = MEMTRACKER_SWAP_CHAIN_IMAGE_KEY;
-        pCI->valid = false;
-        pCI->create_info.image.usage =
-            const_cast<VkSwapchainCreateInfoKHR *>(static_cast<const VkSwapchainCreateInfoKHR *>(pCreateInfo))->imageUsage;
-        break;
-    }
-    default:
-        break;
-    }
-}
-
 // Add a fence, creating one if necessary to our list of fences/fenceIds
 static bool add_fence_info(layer_data *my_data, VkFence fence, VkQueue queue, uint64_t *fenceId) {
     bool skipCall = false;
@@ -445,12 +381,12 @@ static bool validate_usage_flags(layer_data *my_data, void *disp_obj, VkFlags ac
 // Helper function to validate usage flags for images
 // Pulls image info and then sends actual vs. desired usage off to helper above where
 //  an error will be flagged if usage is not correct
-static bool validate_image_usage_flags(layer_data *my_data, void *disp_obj, VkImage image, VkFlags desired, bool strict,
-                                       char const *func_name, char const *usage_string) {
+static bool validate_image_usage_flags(layer_data *dev_data, void *disp_obj, VkImage image, VkFlags desired, VkBool32 strict,
+                                           char const *func_name, char const *usage_string) {
     bool skipCall = false;
-    MT_OBJ_BINDING_INFO *pBindInfo = get_object_binding_info(my_data, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
-    if (pBindInfo) {
-        skipCall = validate_usage_flags(my_data, disp_obj, pBindInfo->create_info.image.usage, desired, strict, (uint64_t)image,
+    auto const image_node = dev_data->imageMap.find(image);
+    if (image_node != dev_data->imageMap.end()) {
+        skipCall = validate_usage_flags(dev_data, disp_obj, image_node->second.createInfo.usage, desired, strict, (uint64_t)image,
                                         VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "image", func_name, usage_string);
     }
     return skipCall;
@@ -459,12 +395,12 @@ static bool validate_image_usage_flags(layer_data *my_data, void *disp_obj, VkIm
 // Helper function to validate usage flags for buffers
 // Pulls buffer info and then sends actual vs. desired usage off to helper above where
 //  an error will be flagged if usage is not correct
-static bool validate_buffer_usage_flags(layer_data *my_data, void *disp_obj, VkBuffer buffer, VkFlags desired, bool strict,
-                                        char const *func_name, char const *usage_string) {
+static bool validate_buffer_usage_flags(layer_data *dev_data, void *disp_obj, VkBuffer buffer, VkFlags desired, VkBool32 strict,
+                                            char const *func_name, char const *usage_string) {
     bool skipCall = false;
-    MT_OBJ_BINDING_INFO *pBindInfo = get_object_binding_info(my_data, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
-    if (pBindInfo) {
-        skipCall = validate_usage_flags(my_data, disp_obj, pBindInfo->create_info.buffer.usage, desired, strict, (uint64_t)buffer,
+    auto const buffer_node = dev_data->bufferMap.find(buffer);
+    if (buffer_node != dev_data->bufferMap.end()) {
+        skipCall = validate_usage_flags(dev_data, disp_obj, buffer_node->second.createInfo.usage, desired, strict, (uint64_t)buffer,
                                         VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "buffer", func_name, usage_string);
     }
     return skipCall;
@@ -501,9 +437,8 @@ static void add_mem_obj_info(layer_data *my_data, void *object, const VkDeviceMe
 static bool validate_memory_is_valid(layer_data *dev_data, VkDeviceMemory mem, const char *functionName,
                                      VkImage image = VK_NULL_HANDLE) {
     if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) {
-        MT_OBJ_BINDING_INFO *pBindInfo =
-            get_object_binding_info(dev_data, reinterpret_cast<const uint64_t &>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
-        if (pBindInfo && !pBindInfo->valid) {
+        auto const image_node = dev_data->imageMap.find(image);
+        if (image_node != dev_data->imageMap.end() && !image_node->second.valid) {
             return log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
                            (uint64_t)(mem), __LINE__, MEMTRACK_INVALID_USAGE_FLAG, "MEM",
                            "%s: Cannot read invalid swapchain image %" PRIx64 ", please fill the memory before using.",
@@ -523,10 +458,9 @@ static bool validate_memory_is_valid(layer_data *dev_data, VkDeviceMemory mem, c
 
 static void set_memory_valid(layer_data *dev_data, VkDeviceMemory mem, bool valid, VkImage image = VK_NULL_HANDLE) {
     if (mem == MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) {
-        MT_OBJ_BINDING_INFO *pBindInfo =
-            get_object_binding_info(dev_data, reinterpret_cast<const uint64_t &>(image), VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
-        if (pBindInfo) {
-            pBindInfo->valid = valid;
+        auto image_node = dev_data->imageMap.find(image);
+        if (image_node != dev_data->imageMap.end()) {
+            image_node->second.valid = valid;
         }
     } else {
         DEVICE_MEM_INFO *pMemObj = get_mem_obj_info(dev_data, mem);
@@ -717,11 +651,11 @@ static const char *object_type_to_string(VkDebugReportObjectTypeEXT type) {
 static bool clear_object_binding(layer_data *dev_data, void *dispObj, uint64_t handle, VkDebugReportObjectTypeEXT type) {
     // TODO : Need to customize images/buffers/swapchains to track mem binding and clear it here appropriately
     bool skipCall = false;
-    MT_OBJ_BINDING_INFO *pObjBindInfo = get_object_binding_info(dev_data, handle, type);
-    if (pObjBindInfo) {
-        DEVICE_MEM_INFO *pMemObjInfo = get_mem_obj_info(dev_data, pObjBindInfo->mem);
+    VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
+    if (pMemBinding) {
+        DEVICE_MEM_INFO *pMemObjInfo = get_mem_obj_info(dev_data, *pMemBinding);
         // TODO : Make sure this is a reasonable way to reset mem binding
-        pObjBindInfo->mem = VK_NULL_HANDLE;
+        *pMemBinding = VK_NULL_HANDLE;
         if (pMemObjInfo) {
             // This obj is bound to a memory object. Remove the reference to this object in that memory object's list,
             // and set the objects memory binding pointer to NULL.
@@ -742,10 +676,8 @@ static bool clear_object_binding(layer_data *dev_data, void *dispObj, uint64_t h
 //  IF a previous binding existed, output validation error
 //  Otherwise, add reference from objectInfo to memoryInfo
 //  Add reference off of objInfo
-//  device is required for error logging, need a dispatchable
-//  object for that.
-static bool set_mem_binding(layer_data *dev_data, void *dispatch_object, VkDeviceMemory mem, uint64_t handle,
-                            VkDebugReportObjectTypeEXT type, const char *apiName) {
+static bool set_mem_binding(layer_data *dev_data, VkDeviceMemory mem, uint64_t handle,
+                                VkDebugReportObjectTypeEXT type, const char *apiName) {
     bool skipCall = false;
     // Handle NULL case separately, just clear previous binding & decrement reference
     if (mem == VK_NULL_HANDLE) {
@@ -753,8 +685,8 @@ static bool set_mem_binding(layer_data *dev_data, void *dispatch_object, VkDevic
         skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_MEM_OBJ,
                            "MEM", "In %s, attempting to Bind Obj(%#" PRIxLEAST64 ") to NULL", apiName, handle);
     } else {
-        MT_OBJ_BINDING_INFO *pObjBindInfo = get_object_binding_info(dev_data, handle, type);
-        if (!pObjBindInfo) {
+        VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
+        if (!pMemBinding) {
             skipCall |=
                 log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_MISSING_MEM_BINDINGS,
                         "MEM", "In %s, attempting to update Binding of %s Obj(%#" PRIxLEAST64 ") that's not in global list",
@@ -763,8 +695,7 @@ static bool set_mem_binding(layer_data *dev_data, void *dispatch_object, VkDevic
             // non-null case so should have real mem obj
             DEVICE_MEM_INFO *pMemInfo = get_mem_obj_info(dev_data, mem);
             if (pMemInfo) {
-                // TODO : Need to track mem binding for obj and report conflict here
-                DEVICE_MEM_INFO *pPrevBinding = get_mem_obj_info(dev_data, pObjBindInfo->mem);
+                DEVICE_MEM_INFO *pPrevBinding = get_mem_obj_info(dev_data, *pMemBinding);
                 if (pPrevBinding != NULL) {
                     skipCall |=
                         log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
@@ -777,12 +708,15 @@ static bool set_mem_binding(layer_data *dev_data, void *dispatch_object, VkDevic
                     // For image objects, make sure default memory state is correctly set
                     // TODO : What's the best/correct way to handle this?
                     if (VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT == type) {
-                        VkImageCreateInfo ici = pObjBindInfo->create_info.image;
-                        if (ici.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
-                            // TODO::  More memory state transition stuff.
+                        auto const image_node = dev_data->imageMap.find(VkImage(handle));
+                        if (image_node != dev_data->imageMap.end()) {
+                            VkImageCreateInfo ici = image_node->second.createInfo;
+                            if (ici.usage & (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
+                                // TODO::  More memory state transition stuff.
+                            }
                         }
                     }
-                    pObjBindInfo->mem = mem;
+                    *pMemBinding = mem;
                 }
             }
         }
@@ -803,18 +737,19 @@ static bool set_sparse_mem_binding(layer_data *dev_data, void *dispObject, VkDev
     if (mem == VK_NULL_HANDLE) {
         skipCall = clear_object_binding(dev_data, dispObject, handle, type);
     } else {
-        MT_OBJ_BINDING_INFO *pObjBindInfo = get_object_binding_info(dev_data, handle, type);
-        if (!pObjBindInfo) {
+        VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
+        if (!pMemBinding) {
             skipCall |= log_msg(
                 dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_MISSING_MEM_BINDINGS, "MEM",
                 "In %s, attempting to update Binding of Obj(%#" PRIxLEAST64 ") that's not in global list()", apiName, handle);
-        }
-        // non-null case so should have real mem obj
-        DEVICE_MEM_INFO *pInfo = get_mem_obj_info(dev_data, mem);
-        if (pInfo) {
-            pInfo->objBindings.insert({handle, type});
-            // Need to set mem binding for this object
-            pObjBindInfo->mem = mem;
+        } else {
+            // non-null case so should have real mem obj
+            DEVICE_MEM_INFO *pInfo = get_mem_obj_info(dev_data, mem);
+            if (pInfo) {
+                pInfo->objBindings.insert({handle, type});
+                // Need to set mem binding for this object
+                *pMemBinding = mem;
+            }
         }
     }
     return skipCall;
@@ -830,21 +765,15 @@ void print_object_map_members(layer_data *my_data, void *dispObj, T const &objec
 }
 
 // For given Object, get 'mem' obj that it's bound to or NULL if no binding
-static bool get_mem_binding_from_object(layer_data *my_data, void *dispObj, const uint64_t handle,
-                                        const VkDebugReportObjectTypeEXT type, VkDeviceMemory *mem) {
+static bool get_mem_binding_from_object(layer_data *dev_data, void *dispObj, const uint64_t handle,
+                                            const VkDebugReportObjectTypeEXT type, VkDeviceMemory *mem) {
     bool skipCall = false;
     *mem = VK_NULL_HANDLE;
-    MT_OBJ_BINDING_INFO *pObjBindInfo = get_object_binding_info(my_data, handle, type);
-    if (pObjBindInfo) {
-        if (pObjBindInfo->mem) {
-            *mem = pObjBindInfo->mem;
-        } else {
-            skipCall =
-                log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_MISSING_MEM_BINDINGS,
-                        "MEM", "Trying to get mem binding for object %#" PRIxLEAST64 " but object has no mem binding", handle);
-        }
+    VkDeviceMemory *pMemBinding = get_object_mem_binding(dev_data, handle, type);
+    if (pMemBinding) {
+        *mem = *pMemBinding;
     } else {
-        skipCall = log_msg(my_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT,
+        skipCall = log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, type, handle, __LINE__, MEMTRACK_INVALID_OBJECT,
                            "MEM", "Trying to get mem binding for object %#" PRIxLEAST64 " but no such object in %s list", handle,
                            object_type_to_string(type));
     }
@@ -2837,7 +2766,7 @@ static bool validate_and_update_drawtime_descriptor_state(
                         if ((pWDS->descriptorType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC) ||
                             (pWDS->descriptorType == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC)) {
                             for (uint32_t j = 0; j < pWDS->descriptorCount; ++j) {
-                                bufferSize = dev_data->bufferMap[pWDS->pBufferInfo[j].buffer].create_info->size;
+                                bufferSize = dev_data->bufferMap[pWDS->pBufferInfo[j].buffer].createInfo.size;
                                 uint32_t dynOffset = pCB->lastBound[VK_PIPELINE_BIND_POINT_GRAPHICS].dynamicOffsets[dynOffsetIndex];
                                 if (pWDS->pBufferInfo[j].range == VK_WHOLE_SIZE) {
                                     if ((dynOffset + pWDS->pBufferInfo[j].offset) > bufferSize) {
@@ -5828,13 +5757,6 @@ vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *p
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     bool skipCall = false;
     loader_platform_thread_lock_mutex(&globalLock);
-#if MTMERGESOURCE
-    auto item = dev_data->bufferBindingMap.find((uint64_t)buffer);
-    if (item != dev_data->bufferBindingMap.end()) {
-        skipCall = clear_object_binding(dev_data, device, (uint64_t)buffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
-        dev_data->bufferBindingMap.erase(item);
-    }
-#endif
     if (!validateIdleBuffer(dev_data, buffer) && !skipCall) {
         loader_platform_thread_unlock_mutex(&globalLock);
         dev_data->device_dispatch_table->DestroyBuffer(device, buffer, pAllocator);
@@ -5859,15 +5781,6 @@ vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocation
 VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) {
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     bool skipCall = false;
-#if MTMERGESOURCE
-    loader_platform_thread_lock_mutex(&globalLock);
-    auto item = dev_data->imageBindingMap.find((uint64_t)image);
-    if (item != dev_data->imageBindingMap.end()) {
-        skipCall = clear_object_binding(dev_data, device, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
-        dev_data->imageBindingMap.erase(item);
-    }
-    loader_platform_thread_unlock_mutex(&globalLock);
-#endif
     if (!skipCall)
         dev_data->device_dispatch_table->DestroyImage(device, image, pAllocator);
 
@@ -5875,7 +5788,7 @@ VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkIma
     const auto& entry = dev_data->imageMap.find(image);
     if (entry != dev_data->imageMap.end()) {
         // Clear any memory mapping for this image
-        const auto &mem_entry = dev_data->memObjMap.find(entry->second.mem);
+        auto mem_entry = dev_data->memObjMap.find(entry->second.mem);
         if (mem_entry != dev_data->memObjMap.end())
             mem_entry->second.image = VK_NULL_HANDLE;
 
@@ -5941,12 +5854,12 @@ vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDevic
     // Track objects tied to memory
     uint64_t buffer_handle = (uint64_t)(buffer);
     bool skipCall =
-        set_mem_binding(dev_data, device, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory");
-    add_object_binding_info(dev_data, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, mem);
-    {
+        set_mem_binding(dev_data, mem, buffer_handle, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "vkBindBufferMemory");
+    auto buffer_node = dev_data->bufferMap.find(buffer);
+    if (buffer_node != dev_data->bufferMap.end()) {
+        buffer_node->second.mem = mem;
         VkMemoryRequirements memRequirements;
-        // MTMTODO : Shouldn't this call down the chain?
-        vkGetBufferMemoryRequirements(device, buffer, &memRequirements);
+        dev_data->device_dispatch_table->GetBufferMemoryRequirements(device, buffer, &memRequirements);
         skipCall |= validate_buffer_image_aliasing(dev_data, buffer_handle, mem, memoryOffset, memRequirements,
                                                    dev_data->memObjMap[mem].bufferRanges, dev_data->memObjMap[mem].imageRanges,
                                                    VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT);
@@ -5961,7 +5874,7 @@ vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDevic
                         memoryOffset, memRequirements.alignment);
         }
         // Validate device limits alignments
-        VkBufferUsageFlags usage = dev_data->bufferMap[buffer].create_info->usage;
+        VkBufferUsageFlags usage = dev_data->bufferMap[buffer].createInfo.usage;
         if (usage & (VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT)) {
             if (vk_safe_modulo(memoryOffset, dev_data->physDevProperties.properties.limits.minTexelBufferOffsetAlignment) != 0) {
                 skipCall |=
@@ -6330,11 +6243,8 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, c
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-#if MTMERGESOURCE
-        add_object_create_info(dev_data, (uint64_t)*pBuffer, VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, pCreateInfo);
-#endif
         // TODO : This doesn't create deep copy of pQueueFamilyIndices so need to fix that if/when we want that data to be valid
-        dev_data->bufferMap[*pBuffer].create_info = unique_ptr<VkBufferCreateInfo>(new VkBufferCreateInfo(*pCreateInfo));
+        dev_data->bufferMap[*pBuffer].createInfo = *pCreateInfo;
         dev_data->bufferMap[*pBuffer].in_use.store(0);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
@@ -6368,9 +6278,6 @@ VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, co
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-#if MTMERGESOURCE
-        add_object_create_info(dev_data, (uint64_t)*pImage, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, pCreateInfo);
-#endif
         IMAGE_LAYOUT_NODE image_node;
         image_node.layout = pCreateInfo->initialLayout;
         image_node.format = pCreateInfo->format;
@@ -8670,24 +8577,25 @@ static bool ValidateBarriers(const char *funcName, VkCommandBuffer cmdBuffer, ui
         }
 
         auto buffer_data = dev_data->bufferMap.find(mem_barrier->buffer);
-        uint64_t buffer_size =
-            buffer_data->second.create_info ? reinterpret_cast<uint64_t &>(buffer_data->second.create_info->size) : 0;
+        VkDeviceSize buffer_size = (buffer_data->second.createInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO)
+                                       ? buffer_data->second.createInfo.size
+                                       : 0;
         if (buffer_data != dev_data->bufferMap.end()) {
             if (mem_barrier->offset >= buffer_size) {
-                skip_call |=
-                    log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
-                            DRAWSTATE_INVALID_BARRIER, "DS", "%s: Buffer Barrier 0x%" PRIx64 " has offset %" PRIu64
-                                                             " whose sum is not less than total size %" PRIu64 ".",
-                            funcName, reinterpret_cast<const uint64_t &>(mem_barrier->buffer),
-                            reinterpret_cast<const uint64_t &>(mem_barrier->offset), buffer_size);
+                skip_call |= log_msg(
+                    dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                    DRAWSTATE_INVALID_BARRIER, "DS",
+                    "%s: Buffer Barrier 0x%" PRIx64 " has offset %" PRIu64 " which is not less than total size %" PRIu64 ".",
+                    funcName, reinterpret_cast<const uint64_t &>(mem_barrier->buffer),
+                    reinterpret_cast<const uint64_t &>(mem_barrier->offset), reinterpret_cast<const uint64_t &>(buffer_size));
             } else if (mem_barrier->size != VK_WHOLE_SIZE && (mem_barrier->offset + mem_barrier->size > buffer_size)) {
-                skip_call |= log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0,
-                                     __LINE__, DRAWSTATE_INVALID_BARRIER, "DS",
-                                     "%s: Buffer Barrier 0x%" PRIx64 " has offset %" PRIu64 " and size %" PRIu64
-                                     " whose sum is greater than total size %" PRIu64 ".",
-                                     funcName, reinterpret_cast<const uint64_t &>(mem_barrier->buffer),
-                                     reinterpret_cast<const uint64_t &>(mem_barrier->offset),
-                                     reinterpret_cast<const uint64_t &>(mem_barrier->size), buffer_size);
+                skip_call |= log_msg(
+                    dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, (VkDebugReportObjectTypeEXT)0, 0, __LINE__,
+                    DRAWSTATE_INVALID_BARRIER, "DS", "%s: Buffer Barrier 0x%" PRIx64 " has offset %" PRIu64 " and size %" PRIu64
+                                                     " whose sum is greater than total size %" PRIu64 ".",
+                    funcName, reinterpret_cast<const uint64_t &>(mem_barrier->buffer),
+                    reinterpret_cast<const uint64_t &>(mem_barrier->offset), reinterpret_cast<const uint64_t &>(mem_barrier->size),
+                    reinterpret_cast<const uint64_t &>(buffer_size));
             }
         }
     }
@@ -10289,33 +10197,35 @@ VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image,
     layer_data *dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = VK_ERROR_VALIDATION_FAILED_EXT;
     bool skipCall = false;
-#if MTMERGESOURCE
     loader_platform_thread_lock_mutex(&globalLock);
-    // Track objects tied to memory
-    uint64_t image_handle = (uint64_t)(image);
-    skipCall =
-        set_mem_binding(dev_data, device, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory");
-    add_object_binding_info(dev_data, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, mem);
-    {
+    auto image_node = dev_data->imageMap.find(image);
+    if (image_node != dev_data->imageMap.end()) {
+        // Track objects tied to memory
+        uint64_t image_handle = reinterpret_cast<uint64_t>(image);
+        skipCall = set_mem_binding(dev_data, mem, image_handle, VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "vkBindImageMemory");
         VkMemoryRequirements memRequirements;
-        vkGetImageMemoryRequirements(device, image, &memRequirements);
+        loader_platform_thread_unlock_mutex(&globalLock);
+        dev_data->device_dispatch_table->GetImageMemoryRequirements(device, image, &memRequirements);
+        loader_platform_thread_lock_mutex(&globalLock);
         skipCall |= validate_buffer_image_aliasing(dev_data, image_handle, mem, memoryOffset, memRequirements,
                                                    dev_data->memObjMap[mem].imageRanges, dev_data->memObjMap[mem].bufferRanges,
                                                    VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT);
-    }
-    print_mem_list(dev_data, device);
-    loader_platform_thread_unlock_mutex(&globalLock);
-#endif
-    if (!skipCall) {
-        result = dev_data->device_dispatch_table->BindImageMemory(device, image, mem, memoryOffset);
-        VkMemoryRequirements memRequirements;
-        dev_data->device_dispatch_table->GetImageMemoryRequirements(device, image, &memRequirements);
-        loader_platform_thread_lock_mutex(&globalLock);
-        dev_data->memObjMap[mem].image = image;
-        dev_data->imageMap[image].mem = mem;
-        dev_data->imageMap[image].memOffset = memoryOffset;
-        dev_data->imageMap[image].memSize = memRequirements.size;
+        print_mem_list(dev_data, device);
         loader_platform_thread_unlock_mutex(&globalLock);
+        if (!skipCall) {
+            result = dev_data->device_dispatch_table->BindImageMemory(device, image, mem, memoryOffset);
+            loader_platform_thread_lock_mutex(&globalLock);
+            dev_data->memObjMap[mem].image = image;
+            image_node->second.mem = mem;
+            image_node->second.memOffset = memoryOffset;
+            image_node->second.memSize = memRequirements.size;
+            loader_platform_thread_unlock_mutex(&globalLock);
+        }
+    } else {
+        log_msg(dev_data->report_data, VK_DEBUG_REPORT_ERROR_BIT_EXT, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT,
+                reinterpret_cast<const uint64_t &>(image), __LINE__, MEMTRACK_INVALID_OBJECT, "MT",
+                "vkBindImageMemory: Cannot find invalid image %" PRIx64 ", has it already been deleted?",
+                reinterpret_cast<const uint64_t &>(image));
     }
     return result;
 }
@@ -10505,11 +10415,9 @@ vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocat
                     }
                     dev_data->imageSubresourceMap.erase(image_sub);
                 }
-#if MTMERGESOURCE
                 skipCall = clear_object_binding(dev_data, device, (uint64_t)swapchain_image,
                                                 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT);
-                dev_data->imageBindingMap.erase((uint64_t)swapchain_image);
-#endif
+                dev_data->imageMap.erase(swapchain_image);
             }
         }
         delete swapchain_data->second;
@@ -10549,23 +10457,18 @@ vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t *pCo
             IMAGE_LAYOUT_NODE image_layout_node;
             image_layout_node.layout = VK_IMAGE_LAYOUT_UNDEFINED;
             image_layout_node.format = swapchain_node->createInfo.imageFormat;
-            dev_data->imageMap[pSwapchainImages[i]].createInfo.mipLevels = 1;
-            dev_data->imageMap[pSwapchainImages[i]].createInfo.arrayLayers = swapchain_node->createInfo.imageArrayLayers;
+            auto &image_node = dev_data->imageMap[pSwapchainImages[i]];
+            image_node.createInfo.mipLevels = 1;
+            image_node.createInfo.arrayLayers = swapchain_node->createInfo.imageArrayLayers;
+            image_node.createInfo.usage = swapchain_node->createInfo.imageUsage;
+            image_node.valid = false;
+            image_node.mem = MEMTRACKER_SWAP_CHAIN_IMAGE_KEY;
             swapchain_node->images.push_back(pSwapchainImages[i]);
             ImageSubresourcePair subpair = {pSwapchainImages[i], false, VkImageSubresource()};
             dev_data->imageSubresourceMap[pSwapchainImages[i]].push_back(subpair);
             dev_data->imageLayoutMap[subpair] = image_layout_node;
             dev_data->device_extensions.imageToSwapchainMap[pSwapchainImages[i]] = swapchain;
         }
-        if (!swapchain_node->images.empty()) {
-            for (auto image : swapchain_node->images) {
-                // Add image object binding, then insert the new Mem Object and then bind it to created image
-#if MTMERGESOURCE
-                add_object_create_info(dev_data, (uint64_t)image, VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT,
-                                       &swapchain_node->createInfo);
-#endif
-            }
-        }
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;