Bug 14084 - Object Tracker, Image, Generic layers

12 files changed, 547 insertions, 297 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c5a40758..16977367 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -46,19 +46,16 @@ else()
     set(PYTHON_CMD "py")
 endif()
 
-option(BUILD_TESTS "Build tests" ON)
+option(BUILD_TESTS "Build tests" OFF)
 
 # loader: Generic VULKAN ICD loader
 # icd: Device dependent (DD) VULKAN components
 # tests: VULKAN tests
 add_subdirectory(loader)
 add_subdirectory(icd)
-#if(NOT WIN32)
-#    # TODO: Tests don't build on Windows 
-#    if(BUILD_TESTS)
-#        add_subdirectory(tests)
-#    endif()
-#endif()
+if(BUILD_TESTS)
+    add_subdirectory(tests)
+endif()
 add_subdirectory(layers)
 add_subdirectory(demos)
 #add_subdirectory(tools/glave)
diff --git a/icd/common/icd-instance.c b/icd/common/icd-instance.c
index ae3b2986..449ff984 100644
--- a/icd/common/icd-instance.c
+++ b/icd/common/icd-instance.c
@@ -187,7 +187,7 @@ void icd_instance_log(const struct icd_instance *instance,
 
     for (logger = instance->loggers; logger; logger = logger->next) {
         if (msg_flags & logger->flags) {
-            logger->func(msg_flags, obj_type, src_object, location,
+            logger->func(msg_flags, obj_type, (uint64_t)src_object, location,
                          msg_code, instance->name, msg, logger->user_data);
         }
     }
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index d49dff46..cea36c20 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -510,7 +510,7 @@ static VkResult nulldrv_viewport_state_create(struct nulldrv_dev *dev,
     struct nulldrv_dynamic_vp *state;
 
     state = (struct nulldrv_dynamic_vp *) nulldrv_base_create(dev,
-            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_VP_STATE);
+            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE);
     if (!state)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -526,7 +526,7 @@ static VkResult nulldrv_raster_state_create(struct nulldrv_dev *dev,
     struct nulldrv_dynamic_rs *state;
 
     state = (struct nulldrv_dynamic_rs *) nulldrv_base_create(dev,
-            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RS_STATE);
+            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE);
     if (!state)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -542,7 +542,7 @@ static VkResult nulldrv_blend_state_create(struct nulldrv_dev *dev,
     struct nulldrv_dynamic_cb *state;
 
     state = (struct nulldrv_dynamic_cb *) nulldrv_base_create(dev,
-            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_CB_STATE);
+            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE);
     if (!state)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -558,7 +558,7 @@ static VkResult nulldrv_ds_state_create(struct nulldrv_dev *dev,
     struct nulldrv_dynamic_ds *state;
 
     state = (struct nulldrv_dynamic_ds *) nulldrv_base_create(dev,
-            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_DS_STATE);
+            sizeof(*state), VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE);
     if (!state)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
diff --git a/include/vk_debug_report_lunarg.h b/include/vk_debug_report_lunarg.h
index 8654a486..89dd02e6 100644
--- a/include/vk_debug_report_lunarg.h
+++ b/include/vk_debug_report_lunarg.h
@@ -66,10 +66,10 @@ typedef enum {
     VK_OBJECT_TYPE_DESCRIPTOR_SET = 17,
     VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 18,
     VK_OBJECT_TYPE_DESCRIPTOR_POOL = 19,
-    VK_OBJECT_TYPE_DYNAMIC_VP_STATE = 20,
-    VK_OBJECT_TYPE_DYNAMIC_RS_STATE = 21,
-    VK_OBJECT_TYPE_DYNAMIC_CB_STATE = 22,
-    VK_OBJECT_TYPE_DYNAMIC_DS_STATE = 23,
+    VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE = 20,
+    VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE = 21,
+    VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE = 22,
+    VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE = 23,
     VK_OBJECT_TYPE_FENCE = 24,
     VK_OBJECT_TYPE_SEMAPHORE = 25,
     VK_OBJECT_TYPE_EVENT = 26,
@@ -84,6 +84,72 @@ typedef enum {
     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 } VkDbgObjectType;
 
+static inline const char* string_VkDbgObjectType(VkDbgObjectType input_value)
+{
+    switch ((VkDbgObjectType)input_value)
+    {
+        case VK_OBJECT_TYPE_BUFFER:
+            return "VK_OBJECT_TYPE_BUFFER";
+        case VK_OBJECT_TYPE_BUFFER_VIEW:
+            return "VK_OBJECT_TYPE_BUFFER_VIEW";
+        case VK_OBJECT_TYPE_ATTACHMENT_VIEW:
+            return "VK_OBJECT_TYPE_ATTACHMENT_VIEW";
+        case VK_OBJECT_TYPE_COMMAND_BUFFER:
+            return "VK_OBJECT_TYPE_COMMAND_BUFFER";
+        case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
+            return "VK_OBJECT_TYPE_DESCRIPTOR_POOL";
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET:
+            return "VK_OBJECT_TYPE_DESCRIPTOR_SET";
+        case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+            return "VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT";
+        case VK_OBJECT_TYPE_DEVICE:
+            return "VK_OBJECT_TYPE_DEVICE";
+        case VK_OBJECT_TYPE_DEVICE_MEMORY:
+            return "VK_OBJECT_TYPE_DEVICE_MEMORY";
+        case VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE:
+            return "VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE";
+        case VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE:
+            return "VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE";
+        case VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE:
+            return "VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE";
+        case VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE:
+            return "VK_OBJECT_TYPE_DYNAMIC_VIEPORT_STATE";
+        case VK_OBJECT_TYPE_EVENT:
+            return "VK_OBJECT_TYPE_EVENT";
+        case VK_OBJECT_TYPE_FENCE:
+            return "VK_OBJECT_TYPE_FENCE";
+        case VK_OBJECT_TYPE_FRAMEBUFFER:
+            return "VK_OBJECT_TYPE_FRAMEBUFFER";
+        case VK_OBJECT_TYPE_IMAGE:
+            return "VK_OBJECT_TYPE_IMAGE";
+        case VK_OBJECT_TYPE_IMAGE_VIEW:
+            return "VK_OBJECT_TYPE_IMAGE_VIEW";
+        case VK_OBJECT_TYPE_INSTANCE:
+            return "VK_OBJECT_TYPE_INSTANCE";
+        case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
+            return "VK_OBJECT_TYPE_PHYSICAL_DEVICE";
+        case VK_OBJECT_TYPE_PIPELINE:
+            return "VK_OBJECT_TYPE_PIPELINE";
+        case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
+            return "VK_OBJECT_TYPE_PIPELINE_LAYOUT";
+        case VK_OBJECT_TYPE_QUERY_POOL:
+            return "VK_OBJECT_TYPE_QUERY_POOL";
+        case VK_OBJECT_TYPE_QUEUE:
+            return "VK_OBJECT_TYPE_QUEUE";
+        case VK_OBJECT_TYPE_RENDER_PASS:
+            return "VK_OBJECT_TYPE_RENDER_PASS";
+        case VK_OBJECT_TYPE_SAMPLER:
+            return "VK_OBJECT_TYPE_SAMPLER";
+        case VK_OBJECT_TYPE_SEMAPHORE:
+            return "VK_OBJECT_TYPE_SEMAPHORE";
+        case VK_OBJECT_TYPE_SHADER:
+            return "VK_OBJECT_TYPE_SHADER";
+        case VK_OBJECT_TYPE_SHADER_MODULE:
+            return "VK_OBJECT_TYPE_SHADER_MODULE";
+        default:
+            return "Unhandled VkObjectType";
+    }
+}
 #define DEBUG_REPORT_EXTENSION_NAME "DEBUG_REPORT"
 
 VK_DEFINE_NONDISP_HANDLE(VkDbgMsgCallback)
diff --git a/layers/CMakeLists.txt b/layers/CMakeLists.txt
index 83658f2b..60fe7cda 100644
--- a/layers/CMakeLists.txt
+++ b/layers/CMakeLists.txt
@@ -119,9 +119,9 @@ add_custom_target(generate_vk_layer_helpers DEPENDS
 	vk_struct_wrappers.cpp
 )
 
-#run_vk_layer_generate(Generic generic_layer.cpp)
+run_vk_layer_generate(Generic generic_layer.cpp)
 run_vk_layer_generate(APIDump api_dump.cpp)
-#run_vk_layer_generate(ObjectTracker object_track.cpp)
+run_vk_layer_generate(ObjectTracker object_track.cpp)
 run_vk_layer_generate(Threading threading.cpp)
 
 add_library(layer_utils SHARED vk_layer_config.cpp vk_layer_extension_utils.cpp)
@@ -136,11 +136,11 @@ endif()
 add_vk_layer(DrawState draw_state.cpp vk_layer_debug_marker_table.cpp vk_layer_table.cpp)
 #add_vk_layer(MemTracker mem_tracker.cpp vk_layer_table.cpp)
 #add_vk_layer(ShaderChecker shader_checker.cpp vk_layer_table.cpp)
-#add_vk_layer(Image image.cpp vk_layer_table.cpp)
+add_vk_layer(Image image.cpp vk_layer_table.cpp)
 add_vk_layer(ParamChecker param_checker.cpp vk_layer_debug_marker_table.cpp vk_layer_table.cpp)
 #add_vk_layer(ScreenShot screenshot.cpp vk_layer_table.cpp)
 # generated
-#add_vk_layer(Generic generic_layer.cpp vk_layer_table.cpp)
+add_vk_layer(Generic generic_layer.cpp vk_layer_table.cpp)
 add_vk_layer(APIDump api_dump.cpp vk_layer_table.cpp)
-#add_vk_layer(ObjectTracker object_track.cpp vk_layer_table.cpp)
+add_vk_layer(ObjectTracker object_track.cpp vk_layer_table.cpp)
 add_vk_layer(Threading threading.cpp vk_layer_table.cpp)
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index bf32fa3e..becde6a3 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2086,7 +2086,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer,
             loader_platform_thread_lock_mutex(&globalLock);
             pCB->status |= CBSTATUS_VIEWPORT_BOUND;
             if (dynamicVpStateMap.find(dynamicViewportState.handle) == dynamicVpStateMap.end()) {
-                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_VP_STATE, dynamicViewportState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE, dynamicViewportState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
                         "Unable to find VkDynamicViewportState object %#" PRIxLEAST64 ", was it ever created?", dynamicViewportState.handle);
             } else {
                 pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_VIEWPORT] = dynamicViewportState.handle;
@@ -2113,7 +2113,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, Vk
             loader_platform_thread_lock_mutex(&globalLock);
             pCB->status |= CBSTATUS_RASTER_BOUND;
             if (dynamicRsStateMap.find(dynamicRasterState.handle) == dynamicRsStateMap.end()) {
-                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RS_STATE, dynamicRasterState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE, dynamicRasterState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
                         "Unable to find VkDynamicRasterState object %#" PRIxLEAST64 ", was it ever created?", dynamicRasterState.handle);
             } else {
                 pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_RASTER] = dynamicRasterState.handle;
@@ -2140,7 +2140,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer
             loader_platform_thread_lock_mutex(&globalLock);
             pCB->status |= CBSTATUS_COLOR_BLEND_BOUND;
             if (dynamicCbStateMap.find(dynamicColorBlendState.handle) == dynamicCbStateMap.end()) {
-                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_CB_STATE, dynamicColorBlendState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE, dynamicColorBlendState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
                         "Unable to find VkDynamicColorBlendState object %#" PRIxLEAST64 ", was it ever created?", dynamicColorBlendState.handle);
             } else {
                 pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_COLOR_BLEND] = dynamicColorBlendState.handle;
@@ -2167,7 +2167,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicDepthStencilState(VkCmdBuffer cmdBuff
             loader_platform_thread_lock_mutex(&globalLock);
             pCB->status |= CBSTATUS_DEPTH_STENCIL_BOUND;
             if (dynamicDsStateMap.find(dynamicDepthStencilState.handle) == dynamicDsStateMap.end()) {
-                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DS_STATE, dynamicDepthStencilState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
+                log_msg(mdd(cmdBuffer), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE, dynamicDepthStencilState.handle, 0, DRAWSTATE_INVALID_DYNAMIC_STATE_OBJECT, "DS",
                         "Unable to find VkDynamicDepthStencilState object %#" PRIxLEAST64 ", was it ever created?", dynamicDepthStencilState.handle);
             } else {
                 pCB->lastBoundDynamicState[VK_STATE_BIND_POINT_DEPTH_STENCIL] = dynamicDepthStencilState.handle;
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 39224688..75eaed19 100644
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -105,13 +105,13 @@ static VkDbgObjectType dynamicStateBindPointToObjType(DYNAMIC_STATE_BIND_POINT s
     switch (sbp)
     {
         case VK_STATE_BIND_POINT_VIEWPORT:
-            return VK_OBJECT_TYPE_DYNAMIC_VP_STATE;
+            return VK_OBJECT_TYPE_DYNAMIC_VIEWPORT_STATE;
         case VK_STATE_BIND_POINT_RASTER:
-            return VK_OBJECT_TYPE_DYNAMIC_RS_STATE;
+            return VK_OBJECT_TYPE_DYNAMIC_RASTER_STATE;
         case VK_STATE_BIND_POINT_COLOR_BLEND:
-            return VK_OBJECT_TYPE_DYNAMIC_CB_STATE;
+            return VK_OBJECT_TYPE_DYNAMIC_COLOR_BLEND_STATE;
         case VK_STATE_BIND_POINT_DEPTH_STENCIL:
-            return VK_OBJECT_TYPE_DYNAMIC_DS_STATE;
+            return VK_OBJECT_TYPE_DYNAMIC_DEPTH_STENCIL_STATE;
         default:
             return VK_OBJECT_TYPE_MAX_ENUM;
     }
diff --git a/layers/image.cpp b/layers/image.cpp
index 224a5dd8..719e5af0 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -55,7 +55,7 @@ static device_table_map image_device_table_map;
 static instance_table_map image_instance_table_map;
 
 // "my device data"
-debug_report_data *mdd(VkObject object)
+debug_report_data *mdd(const void* object)
 {
     dispatch_key key = get_dispatch_key(object);
     layer_data *data = get_my_data_ptr(key, layer_data_map);
@@ -257,13 +257,13 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreat
         if(result != VK_SUCCESS)
         {
             char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, cannot be validated";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", str);
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", str);
         }
 
         if((properties.linearTilingFeatures) == 0 && (properties.optimalTilingFeatures == 0))
         {
             char const str[] = "vkCreateImage parameter, VkFormat pCreateInfo->format, contains unsupported format";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", str);
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", str);
         }
     }
 
@@ -286,7 +286,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
             {
                 std::stringstream ss;
                 ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], cannot be validated";
-                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
+                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
                 continue;
             }
 
@@ -294,7 +294,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
             {
                 std::stringstream ss;
                 ss << "vkCreateRenderPass parameter, VkFormat in pCreateInfo->pAttachments[" << i << "], contains unsupported format";
-                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
+                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
             }
         }
     }
@@ -306,7 +306,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
         {
             std::stringstream ss;
             ss << "vkCreateRenderPass parameter, VkImageLayout in pCreateInfo->pAttachments[" << i << "], is unrecognized";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
         }
     }
 
@@ -316,7 +316,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
         {
             std::stringstream ss;
             ss << "vkCreateRenderPass parameter, VkAttachmentLoadOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
         }
     }
 
@@ -326,7 +326,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
         {
             std::stringstream ss;
             ss << "vkCreateRenderPass parameter, VkAttachmentStoreOp in pCreateInfo->pAttachments[" << i << "], is unrecognized";
-            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkObjectType)0, NULL, 0, 1, "IMAGE", ss.str().c_str());
+            log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, (VkDbgObjectType)0, 0, 0, 1, "IMAGE", ss.str().c_str());
         }
     }
 
diff --git a/layers/object_track.h b/layers/object_track.h
index cab77179..6fd4beb0 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -54,22 +54,18 @@ typedef enum _ObjectStatusFlagBits
 } ObjectStatusFlagBits;
 
 typedef struct _OBJTRACK_NODE {
-    VkObject          vkObj;
-    VkObjectType      objType;
-    ObjectStatusFlags status;
+    uint64_t             vkObj;
+    VkDbgObjectType      objType;
+    ObjectStatusFlags    status;
 } OBJTRACK_NODE;
 
 // prototype for extension functions
 uint64_t objTrackGetObjectCount(VkDevice device);
-VkResult objTrackGetObjects(VkDevice device, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray);
-uint64_t objTrackGetObjectsOfTypeCount(VkDevice, VkObjectType type);
-VkResult objTrackGetObjectsOfType(VkDevice, VkObjectType type, uint64_t objCount, OBJTRACK_NODE* pObjNodeArray);
+uint64_t objTrackGetObjectsOfTypeCount(VkDevice, VkDbgObjectType type);
 
 // Func ptr typedefs
 typedef uint64_t (*OBJ_TRACK_GET_OBJECT_COUNT)(VkDevice);
-typedef VkResult (*OBJ_TRACK_GET_OBJECTS)(VkDevice, VkObjectType, uint64_t, OBJTRACK_NODE*);
-typedef uint64_t (*OBJ_TRACK_GET_OBJECTS_OF_TYPE_COUNT)(VkDevice, VkObjectType);
-typedef VkResult (*OBJ_TRACK_GET_OBJECTS_OF_TYPE)(VkDevice, VkObjectType, uint64_t, OBJTRACK_NODE*);
+typedef uint64_t (*OBJ_TRACK_GET_OBJECTS_OF_TYPE_COUNT)(VkDevice, VkDbgObjectType);
 
 typedef struct _layer_data {
     debug_report_data *report_data;
@@ -88,9 +84,9 @@ static int objLockInitialized = 0;
 static loader_platform_thread_mutex objLock;
 
 // Objects stored in a global map w/ struct containing basic info
-unordered_map<VkObject, OBJTRACK_NODE*> objMap;
+// unordered_map<const void*, OBJTRACK_NODE*> objMap;
 
-#define NUM_OBJECT_TYPES (VK_NUM_OBJECT_TYPE + (VK_OBJECT_TYPE_SWAP_CHAIN_WSI - VK_OBJECT_TYPE_DISPLAY_WSI))
+#define NUM_OBJECT_TYPES VK_OBJECT_TYPE_NUM
 
 static uint64_t                         numObjs[NUM_OBJECT_TYPES]     = {0};
 static uint64_t                         numTotalObjs                  = 0;
@@ -124,7 +120,7 @@ typedef enum _DispTableType
     DISP_TBL_TYPE_DEVICE,
 } DispTableType;
 
-debug_report_data *mdd(VkObject object)
+debug_report_data *mdd(const void* object)
 {
     dispatch_key key = get_dispatch_key(object);
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
@@ -171,36 +167,6 @@ objTypeToIndex(
     return index;
 }
 
-// Validate that object is in the object map
-static void
-validate_object(
-    const VkObject dispatchable_object,
-    const VkObject object)
-{
-    if (objMap.find(object) == objMap.end()) {
-        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid Object %p", object);
-    }
-}
-
-// Validate that object parameter matches designated object type
-static void
-validateObjectType(
-    VkObject      dispatchable_object,
-    const char   *apiName,
-    VkObjectType  objType,
-    VkObject      object)
-{
-    if (objMap.find(object) != objMap.end()) {
-        OBJTRACK_NODE* pNode = objMap[object];
-        // Found our object, check type
-        if (strcmp(string_VkObjectType(pNode->objType), string_VkObjectType(objType)) != 0) {
-            log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, object, 0, OBJTRACK_OBJECT_TYPE_MISMATCH, "OBJTRACK",
-                "ERROR: Object Parameter Type %s does not match designated type %s", string_VkObjectType(pNode->objType), string_VkObjectType(objType));
-        }
-    }
-}
-
 // Add new queue to head of global queue list
 static void
 addQueueInfo(
@@ -217,7 +183,7 @@ addQueueInfo(
         g_pQueueInfo          = pQueueInfo;
     }
     else {
-        log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, queue, 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK",
+        log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast<VkUintPtrLeast64>(queue), 0, OBJTRACK_INTERNAL_ERROR, "OBJTRACK",
             "ERROR:  VK_ERROR_OUT_OF_HOST_MEMORY -- could not allocate memory for Queue Information");
     }
 }
@@ -242,99 +208,6 @@ destroyQueueMemRefLists(void)
     g_pQueueInfo = pQueueInfo;
 }
 
-
-static void
-create_obj(
-    VkObject     dispatchable_object,
-    VkObject     vkObj,
-    VkObjectType objType)
-{
-    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
-        "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkObjectType(objType),
-        reinterpret_cast<VkUintPtrLeast64>(vkObj));
-
-    OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
-    pNewObjNode->vkObj = vkObj;
-    pNewObjNode->objType = objType;
-    pNewObjNode->status  = OBJSTATUS_NONE;
-    objMap[vkObj] = pNewObjNode;
-    uint32_t objIndex = objTypeToIndex(objType);
-    numObjs[objIndex]++;
-    numTotalObjs++;
-}
-
-// Parse global list to find obj type, then remove obj from obj type list, finally
-//   remove obj from global list
-static void
-destroy_obj(
-    VkObject dispatchable_object,
-    VkObject vkObj)
-{
-    if (objMap.find(vkObj) != objMap.end()) {
-        OBJTRACK_NODE* pNode = objMap[vkObj];
-        uint32_t objIndex = objTypeToIndex(pNode->objType);
-        assert(numTotalObjs > 0);
-        numTotalObjs--;
-        assert(numObjs[objIndex] > 0);
-        numObjs[objIndex]--;
-        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
-            "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",
-            string_VkObjectType(pNode->objType), reinterpret_cast<VkUintPtrLeast64>(pNode->vkObj), numTotalObjs, numObjs[objIndex],
-            string_VkObjectType(pNode->objType));
-
-        delete pNode;
-        objMap.erase(vkObj);
-    } else {
-        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
-            "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",
-            reinterpret_cast<VkUintPtrLeast64>(vkObj));
-    }
-}
-
-// Set selected flag state for an object node
-static void
-set_status(
-    VkObject          dispatchable_object,
-    VkObject          vkObj,
-    VkObjectType      objType,
-    ObjectStatusFlags status_flag)
-{
-    if (vkObj != VK_NULL_HANDLE) {
-        if (objMap.find(vkObj) != objMap.end()) {
-            OBJTRACK_NODE* pNode = objMap[vkObj];
-            pNode->status |= status_flag;
-            return;
-        }
-        else {
-            // If we do not find it print an error
-            log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkObjectType) 0, vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
-                "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",
-                reinterpret_cast<VkUintPtrLeast64>(vkObj), string_VkObjectType(objType));
-        }
-    }
-}
-
-// Reset selected flag state for an object node
-static void
-reset_status(
-    VkObject          dispatchable_object,
-    VkObject          vkObj,
-    VkObjectType      objType,
-    ObjectStatusFlags status_flag)
-{
-    if (objMap.find(vkObj) != objMap.end()) {
-        OBJTRACK_NODE* pNode = objMap[vkObj];
-        pNode->status &= ~status_flag;
-        return;
-    }
-    else {
-        // If we do not find it print an error
-        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, vkObj, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
-            "Unable to reset status for non-existent object 0x%" PRIxLEAST64 " of %s type",
-            reinterpret_cast<VkUintPtrLeast64>(vkObj), string_VkObjectType(objType));
-    }
-}
-
 static void
 setGpuQueueInfoState(
     uint32_t  count,
@@ -359,15 +232,17 @@ validateQueueFlags(
     }
     if (pQueueInfo != NULL) {
         if ((queueInfo != NULL) && (queueInfo[pQueueInfo->queueNodeIndex].queueFlags & VK_QUEUE_SPARSE_MEMMGR_BIT) == 0) {
-            log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, queue, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
+            log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast<VkUintPtrLeast64>(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
                 "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_MEMMGR_BIT not set", function);
         } else {
-            log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, queue, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
+            log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_QUEUE, reinterpret_cast<VkUintPtrLeast64>(queue), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",
                 "Attempting %s on a possibly non-memory-management capable queue -- VK_QUEUE_SPARSE_MEMMGR_BIT not known", function);
         }
     }
 }
 
+/* TODO: Port to new type safety */
+#if 0
 // Check object status for selected flag state
 static VkBool32
 validate_status(
@@ -399,6 +274,7 @@ validate_status(
         return VK_FALSE;
     }
 }
+#endif
 
 #include "vk_dispatch_table_helper.h"
 static void
@@ -438,11 +314,126 @@ initObjectTracker(
     }
 }
 
+//
+// Forward declares of generated routines
+//
+
+static void create_obj(VkInstance dispatchable_object, VkInstance object, VkDbgObjectType objType);
+static void create_obj(VkDevice dispatchable_object, VkDevice object, VkDbgObjectType objType);
+static void create_obj(VkDevice dispatchable_object, VkDescriptorSet object, VkDbgObjectType objType);
+static void validate_object(VkInstance dispatchable_object, VkInstance object);
+static void validate_object(VkDevice dispatchable_object, VkDevice object);
+static void validate_object(VkDevice dispatchable_object, VkDescriptorPool object);
+static void destroy_obj(VkInstance dispatchable_object, VkInstance object);
+static void destroy_obj(VkDevice dispatchable_object, VkDeviceMemory object);
+static void set_status(VkDevice dispatchable_object, VkDeviceMemory object, VkDbgObjectType objType, ObjectStatusFlags status_flag);
+static void reset_status(VkDevice dispatchable_object, VkDeviceMemory object, VkDbgObjectType objType, ObjectStatusFlags status_flag);
+#if 0
+static VkBool32 validate_status(VkDevice dispatchable_object, VkFence object, VkDbgObjectType objType,
+    ObjectStatusFlags status_mask, ObjectStatusFlags status_flag, VkFlags msg_flags, OBJECT_TRACK_ERROR  error_code,
+    const char         *fail_msg);
+#endif
+extern unordered_map<const void*, OBJTRACK_NODE*> VkBufferMap;
+extern unordered_map<const void*, OBJTRACK_NODE*> VkFenceMap;
+extern unordered_map<const void*, OBJTRACK_NODE*> VkSemaphoreMap;
+extern unordered_map<const void*, OBJTRACK_NODE*> VkCmdBufferMap;
+extern unordered_map<const void*, OBJTRACK_NODE*> VkSwapChainWSIMap;
+
+static void validate_object(VkQueue dispatchable_object, VkBuffer object)
+{
+    if (VkBufferMap.find((void*)object.handle) != VkBufferMap.end()) {
+        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid Object %p",reinterpret_cast<VkUintPtrLeast64>(object.handle));
+    }
+}
 
+static void set_status(VkQueue dispatchable_object, VkFence object, VkDbgObjectType objType, ObjectStatusFlags status_flag)
+{
+    if (object != VK_NULL_HANDLE) {
+        if (VkFenceMap.find((void*)object.handle) != VkFenceMap.end()) {
+            OBJTRACK_NODE* pNode = VkFenceMap[(void*)object.handle];
+            pNode->status |= status_flag;
+            return;
+        }
+        else {
+            // If we do not find it print an error
+            log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<VkUintPtrLeast64>(object.handle), 0, OBJTRACK_NONE, "OBJTRACK",
+                "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",
+                reinterpret_cast<VkUintPtrLeast64>(object.handle), string_VkDbgObjectType(objType));
+        }
+    }
+}
+
+static void validate_object(VkQueue dispatchable_object, VkSemaphore object)
+{
+    if (VkSemaphoreMap.find((void*)object.handle) == VkSemaphoreMap.end()) {
+        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid Object %p",reinterpret_cast<VkUintPtrLeast64>(object.handle));
+    }
+}
+
+static void validate_object(VkDevice dispatchable_object, VkCmdBuffer object)
+{
+    if (VkSemaphoreMap.find(object) == VkSemaphoreMap.end()) {
+        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid Object %p",reinterpret_cast<VkUintPtrLeast64>(object));
+    }
+}
+
+static void create_obj(VkDevice dispatchable_object, VkCmdBuffer vkObj, VkDbgObjectType objType)
+{
+    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<VkUintPtrLeast64>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",
+        "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
+        reinterpret_cast<VkUintPtrLeast64>(vkObj));
+
+    OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
+    pNewObjNode->objType = objType;
+    pNewObjNode->status  = OBJSTATUS_NONE;
+    pNewObjNode->vkObj  = reinterpret_cast<VkUintPtrLeast64>(vkObj);
+    VkCmdBufferMap[vkObj] = pNewObjNode;
+    uint32_t objIndex = objTypeToIndex(objType);
+    numObjs[objIndex]++;
+    numTotalObjs++;
+}
+static void create_obj(VkDevice dispatchable_object, VkSwapChainWSI vkObj, VkDbgObjectType objType)
+{
+    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<VkUintPtrLeast64>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",
+        "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
+        reinterpret_cast<VkUintPtrLeast64>(vkObj));
+
+    OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
+    pNewObjNode->objType = objType;
+    pNewObjNode->status  = OBJSTATUS_NONE;
+    pNewObjNode->vkObj  = reinterpret_cast<VkUintPtrLeast64>(vkObj);
+    VkSwapChainWSIMap[vkObj] = pNewObjNode;
+    uint32_t objIndex = objTypeToIndex(objType);
+    numObjs[objIndex]++;
+    numTotalObjs++;
+}
+static void destroy_obj(VkSwapChainWSI dispatchable_object, VkSwapChainWSI object)
+{
+    if (VkSwapChainWSIMap.find(object) != VkSwapChainWSIMap.end()) {
+        OBJTRACK_NODE* pNode = VkSwapChainWSIMap[object];
+        uint32_t objIndex = objTypeToIndex(pNode->objType);
+        assert(numTotalObjs > 0);
+        numTotalObjs--;
+        assert(numObjs[objIndex] > 0);
+        numObjs[objIndex]--;
+        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_NONE, "OBJTRACK",
+           "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",
+            string_VkDbgObjectType(pNode->objType), reinterpret_cast<VkUintPtrLeast64>(object), numTotalObjs, numObjs[objIndex],
+            string_VkDbgObjectType(pNode->objType));
+        delete pNode;
+        VkSwapChainWSIMap.erase(object);
+    } else {
+        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_NONE, "OBJTRACK",
+            "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",
+           reinterpret_cast<VkUintPtrLeast64>(object));
+    }
+}
 //
 // Non-auto-generated API functions called by generated code
 //
-
 VkResult
 explicit_CreateInstance(
     const VkInstanceCreateInfo *pCreateInfo,
@@ -468,45 +459,6 @@ explicit_CreateInstance(
 }
 
 VkResult
-explicit_DestroyInstance(
-    VkInstance instance)
-{
-    loader_platform_thread_lock_mutex(&objLock);
-    validate_object(instance, instance);
-
-    destroy_obj(instance, instance);
-    // Report any remaining objects in LL
-    for (auto it = objMap.begin(); it != objMap.end(); ++it) {
-        OBJTRACK_NODE* pNode = it->second;        if ((pNode->objType == VK_OBJECT_TYPE_PHYSICAL_DEVICE) || (pNode->objType == VK_OBJECT_TYPE_QUEUE)) {
-            // Cannot destroy physical device so ignore
-        } else {
-            log_msg(mid(instance), VK_DBG_REPORT_ERROR_BIT, pNode->objType, pNode->vkObj, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",
-                "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkObjectType(pNode->objType),
-                reinterpret_cast<VkUintPtrLeast64>(pNode->vkObj));
-        }
-    }
-
-    dispatch_key key = get_dispatch_key(instance);
-    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, instance);
-    VkResult result = pInstanceTable->DestroyInstance(instance);
-
-    // Clean up logging callback, if any
-    layer_data *my_data = get_my_data_ptr(key, layer_data_map);
-    if (my_data->logging_callback) {
-        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);
-    }
-
-    layer_debug_report_destroy_instance(mid(instance));
-    layer_data_map.erase(pInstanceTable);
-
-    ObjectTracker_instance_table_map.erase(key);
-    assert(ObjectTracker_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");
-
-    loader_platform_thread_unlock_mutex(&objLock);
-    return result;
-}
-
-VkResult
 explicit_GetPhysicalDeviceQueueProperties(
     VkPhysicalDevice                 gpu,
     uint32_t                         count,
@@ -543,38 +495,6 @@ explicit_CreateDevice(
 }
 
 VkResult
-explicit_DestroyDevice(
-    VkDevice device)
-{
-    loader_platform_thread_lock_mutex(&objLock);
-    validate_object(device, device);
-    destroy_obj(device, device);
-    // Report any remaining objects
-    for (auto it = objMap.begin(); it != objMap.end(); ++it) {
-        OBJTRACK_NODE* pNode = it->second;
-        if ((pNode->objType == VK_OBJECT_TYPE_PHYSICAL_DEVICE) || (pNode->objType == VK_OBJECT_TYPE_QUEUE)) {
-            // Cannot destroy physical device so ignore
-        } else {
-            log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, device, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",
-                "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkObjectType(pNode->objType),
-                reinterpret_cast<VkUintPtrLeast64>(pNode->vkObj));
-        }
-    }
-    // Clean up Queue's MemRef Linked Lists
-    destroyQueueMemRefLists();
-
-    loader_platform_thread_unlock_mutex(&objLock);
-
-    dispatch_key key = get_dispatch_key(device);
-    VkLayerDispatchTable *pDisp = get_dispatch_table(ObjectTracker_device_table_map, device);
-    VkResult result = pDisp->DestroyDevice(device);
-    ObjectTracker_device_table_map.erase(key);
-    assert(ObjectTracker_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");
-
-    return result;
-}
-
-VkResult
 explicit_GetDeviceQueue(
     VkDevice  device,
     uint32_t  queueNodeIndex,
@@ -648,45 +568,6 @@ explicit_UnmapMemory(
 }
 
 VkResult
-explicit_DestroyObject(
-    VkDevice     device,
-    VkObjectType objType,
-    VkObject     object)
-{
-    loader_platform_thread_lock_mutex(&objLock);
-    validate_object(device, device);
-    validate_object(device, object);
-    loader_platform_thread_unlock_mutex(&objLock);
-
-    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->DestroyObject(device, objType, object);
-
-    loader_platform_thread_lock_mutex(&objLock);
-    validateObjectType(device, "vkDestroyObject", objType, object);
-    destroy_obj(device, object);
-    loader_platform_thread_unlock_mutex(&objLock);
-
-    return result;
-}
-
-VkResult
-explicit_GetObjectMemoryRequirements(
-    VkDevice               device,
-    VkObjectType           objType,
-    VkObject               object,
-    VkMemoryRequirements*  pMemoryRequirements)
-{
-    loader_platform_thread_lock_mutex(&objLock);
-    validateObjectType(device, "vkGetObjectMemoryRequirements", objType, object);
-    validate_object(device, device);
-    validate_object(device, object);
-    loader_platform_thread_unlock_mutex(&objLock);
-
-    VkResult result = get_dispatch_table(ObjectTracker_device_table_map, device)->GetObjectMemoryRequirements(device, objType, object, pMemoryRequirements);
-
-    return result;
-}
-
-VkResult
 explicit_QueueBindSparseBufferMemory(
     VkQueue                       queue,
     VkBuffer                      buffer,
@@ -739,8 +620,10 @@ explicit_GetFenceStatus(
 {
     loader_platform_thread_lock_mutex(&objLock);
     // Warn if submitted_flag is not set
+#if 0
     validate_status(device, fence, VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED,
         VK_DBG_REPORT_ERROR_BIT, OBJTRACK_INVALID_FENCE, "Status Requested for Unsubmitted Fence");
+#endif
     validate_object(device, device);
     loader_platform_thread_unlock_mutex(&objLock);
 
@@ -758,11 +641,13 @@ explicit_WaitForFences(
     uint64_t       timeout)
 {
     loader_platform_thread_lock_mutex(&objLock);
+#if 0
     // Warn if waiting on unsubmitted fence
     for (uint32_t i = 0; i < fenceCount; i++) {
         validate_status(device, pFences[i], VK_OBJECT_TYPE_FENCE, OBJSTATUS_FENCE_IS_SUBMITTED, OBJSTATUS_FENCE_IS_SUBMITTED,
             VK_DBG_REPORT_ERROR_BIT, OBJTRACK_INVALID_FENCE, "Waiting for Unsubmitted Fence");
     }
+#endif
     validate_object(device, device);
     loader_platform_thread_unlock_mutex(&objLock);
 
@@ -829,3 +714,4 @@ explicit_FreeMemory(
 
     return result;
 }
+
diff --git a/layers/vk_layer_table.h b/layers/vk_layer_table.h
index 27784033..fbf2a8cd 100644
--- a/layers/vk_layer_table.h
+++ b/layers/vk_layer_table.h
@@ -34,7 +34,7 @@ VkLayerInstanceDispatchTable * initInstanceTable(instance_table_map &map, const
 
 typedef void *dispatch_key;
 
-static inline dispatch_key get_dispatch_key(void* object)
+static inline dispatch_key get_dispatch_key(const void* object)
 {
     return (dispatch_key) *(VkLayerDispatchTable **) object;
 }
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index cfc07bac..d5ff77a9 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -593,14 +593,14 @@ class GenericLayerSubcommand(Subcommand):
                      '{\n'
                      '    char str[1024];\n'
                      '    sprintf(str, "At start of layered %s\\n");\n'
-                     '    layerCbMsg(VK_DBG_REPORT_INFO_BIT,VK_OBJECT_TYPE_PHYSICAL_DEVICE, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n'
+                     '    layerCbMsg(VK_DBG_REPORT_INFO_BIT,VK_OBJECT_TYPE_PHYSICAL_DEVICE, (uint64_t)physicalDevice, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '    %sdevice_dispatch_table(*pDevice)->%s;\n'
                      '    if (result == VK_SUCCESS) {\n'
                      '        enable_debug_report(pCreateInfo->extensionCount, pCreateInfo->ppEnabledExtensionNames);\n'
                      '        createDeviceRegisterExtensions(pCreateInfo, *pDevice);\n'
                      '    }\n'
                      '    sprintf(str, "Completed layered %s\\n");\n'
-                     '    layerCbMsg(VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n'
+                     '    layerCbMsg(VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, (uint64_t)physicalDevice, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '    fflush(stdout);\n'
                      '    %s'
                      '}' % (qual, decl, proto.name, ret_val, proto.c_call(), proto.name, stmt))
@@ -1046,13 +1046,313 @@ class ObjectTrackerSubcommand(Subcommand):
         header_txt.append('')
         return "\n".join(header_txt)
 
+    def generate_maps(self):
+        maps_txt = []
+        for o in vulkan.core.objects:
+            maps_txt.append('unordered_map<const void*, OBJTRACK_NODE*> %sMap;' % (o))
+        maps_txt.append('unordered_map<const void*, OBJTRACK_NODE*> VkSwapChainWSIMap;')
+        return "\n".join(maps_txt)
+
+    def generate_procs(self):
+        procs_txt = []
+        for o in vulkan.core.objects:
+            procs_txt.append('%s' % self.lineinfo.get())
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('static void create_obj(%s dispatchable_object, %s vkObj, VkDbgObjectType objType)' % (o, o))
+                procs_txt.append('{')
+                procs_txt.append('    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<VkUintPtrLeast64>(vkObj), 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('        "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),')
+                procs_txt.append('        reinterpret_cast<VkUintPtrLeast64>(vkObj));')
+            else:
+                procs_txt.append('static void create_obj(VkDevice dispatchable_object, %s vkObj, VkDbgObjectType objType)' % (o))
+                procs_txt.append('{')
+                procs_txt.append('    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('        "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),')
+                procs_txt.append('        reinterpret_cast<VkUintPtrLeast64>(vkObj.handle));')
+            procs_txt.append('')
+            procs_txt.append('    OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;')
+            procs_txt.append('    pNewObjNode->objType = objType;')
+            procs_txt.append('    pNewObjNode->status  = OBJSTATUS_NONE;')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('    pNewObjNode->vkObj  = reinterpret_cast<VkUintPtrLeast64>(vkObj);')
+                procs_txt.append('    %sMap[vkObj] = pNewObjNode;' % (o))
+            else:
+                procs_txt.append('    pNewObjNode->vkObj  = reinterpret_cast<VkUintPtrLeast64>(vkObj.handle);')
+                procs_txt.append('    %sMap[(void*)vkObj.handle] = pNewObjNode;' % (o))
+            procs_txt.append('    uint32_t objIndex = objTypeToIndex(objType);')
+            procs_txt.append('    numObjs[objIndex]++;')
+            procs_txt.append('    numTotalObjs++;')
+            procs_txt.append('}')
+            procs_txt.append('')
+            procs_txt.append('%s' % self.lineinfo.get())
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('static void validate_object(%s dispatchable_object, %s object)' % (o, o))
+            else:
+                procs_txt.append('static void validate_object(VkDevice dispatchable_object, %s object)' % (o))
+            procs_txt.append('{')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('    if (%sMap.find(object) == %sMap.end()) {' % (o, o))
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Invalid Object %p",reinterpret_cast<VkUintPtrLeast64>(object));')
+            else:
+                procs_txt.append('    if (%sMap.find((void*)object.handle) == %sMap.end()) {' % (o, o))
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Invalid Object %p",reinterpret_cast<VkUintPtrLeast64>(object.handle));')
+            procs_txt.append('    }')
+            procs_txt.append('}')
+            procs_txt.append('')
+            procs_txt.append('')
+            procs_txt.append('%s' % self.lineinfo.get())
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('static void destroy_obj(%s dispatchable_object, %s object)' % (o, o))
+            else:
+                procs_txt.append('static void destroy_obj(VkDevice dispatchable_object, %s object)' % (o))
+            procs_txt.append('{')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('    if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+                procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object];' % (o))
+            else:
+                procs_txt.append('    if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
+                procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+            procs_txt.append('        uint32_t objIndex = objTypeToIndex(pNode->objType);')
+            procs_txt.append('        assert(numTotalObjs > 0);')
+            procs_txt.append('        numTotalObjs--;')
+            procs_txt.append('        assert(numObjs[objIndex] > 0);')
+            procs_txt.append('        numObjs[objIndex]--;')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('           "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",')
+                procs_txt.append('            string_VkDbgObjectType(pNode->objType), reinterpret_cast<VkUintPtrLeast64>(object), numTotalObjs, numObjs[objIndex],')
+            else:
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('           "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",')
+                procs_txt.append('            string_VkDbgObjectType(pNode->objType), reinterpret_cast<VkUintPtrLeast64>(object.handle), numTotalObjs, numObjs[objIndex],')
+            procs_txt.append('            string_VkDbgObjectType(pNode->objType));')
+            procs_txt.append('        delete pNode;')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('        %sMap.erase(object);' % (o))
+                procs_txt.append('    } else {')
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('            "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",')
+                procs_txt.append('           reinterpret_cast<VkUintPtrLeast64>(object));')
+                procs_txt.append('    }')
+            else:
+                procs_txt.append('        %sMap.erase((void*)object.handle);' % (o))
+                procs_txt.append('    } else {')
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('            "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",')
+                procs_txt.append('           reinterpret_cast<VkUintPtrLeast64>(object.handle));')
+                procs_txt.append('    }')
+            procs_txt.append('}')
+            procs_txt.append('')
+            procs_txt.append('%s' % self.lineinfo.get())
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('static void set_status(%s dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o, o))
+                procs_txt.append('{')
+                procs_txt.append('    if (object != VK_NULL_HANDLE) {')
+                procs_txt.append('        if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+                procs_txt.append('            OBJTRACK_NODE* pNode = %sMap[object];' % (o))
+            else:
+                procs_txt.append('static void set_status(VkDevice dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o))
+                procs_txt.append('{')
+                procs_txt.append('    if (object.handle != VK_NULL_HANDLE) {')
+                procs_txt.append('        if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
+                procs_txt.append('            OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+            procs_txt.append('           pNode->status |= status_flag;')
+            procs_txt.append('            return;')
+            procs_txt.append('        }')
+            procs_txt.append('        else {')
+            procs_txt.append('            // If we do not find it print an error')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('            log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('                "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+                procs_txt.append('                reinterpret_cast<VkUintPtrLeast64>(object), string_VkDbgObjectType(objType));')
+            else:
+                procs_txt.append('            log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",')
+                procs_txt.append('                "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+                procs_txt.append('                reinterpret_cast<VkUintPtrLeast64>(object.handle), string_VkDbgObjectType(objType));')
+            procs_txt.append('        }')
+            procs_txt.append('    }')
+            procs_txt.append('}')
+            procs_txt.append('')
+            procs_txt.append('%s' % self.lineinfo.get())
+            procs_txt.append('static VkBool32 validate_status(')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('%s dispatchable_object, %s object,' % (o, o))
+            else:
+                procs_txt.append('VkDevice dispatchable_object, %s object,' % (o))
+            procs_txt.append('    VkDbgObjectType     objType,')
+            procs_txt.append('    ObjectStatusFlags   status_mask,')
+            procs_txt.append('    ObjectStatusFlags   status_flag,')
+            procs_txt.append('    VkFlags             msg_flags,')
+            procs_txt.append('    OBJECT_TRACK_ERROR  error_code,')
+            procs_txt.append('    const char         *fail_msg)')
+            procs_txt.append('{')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('    if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+                procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object];' % (o))
+            else:
+                procs_txt.append('    if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
+                procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+            procs_txt.append('        if ((pNode->status & status_mask) != status_flag) {')
+            procs_txt.append('           char str[1024];')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('            log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+                procs_txt.append('                "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkDbgObjectType(objType),')
+                procs_txt.append('                 reinterpret_cast<VkUintPtrLeast64>(object), fail_msg);')
+            else:
+                procs_txt.append('            log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, object.handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+                procs_txt.append('                "OBJECT VALIDATION WARNING: %s object 0x%" PRIxLEAST64 ": %s", string_VkDbgObjectType(objType),')
+                procs_txt.append('                 reinterpret_cast<VkUintPtrLeast64>(object.handle), fail_msg);')
+            procs_txt.append('            return VK_FALSE;')
+            procs_txt.append('        }')
+            procs_txt.append('        return VK_TRUE;')
+            procs_txt.append('    }')
+            procs_txt.append('    else {')
+            procs_txt.append('        // If we do not find it print an error')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('        log_msg(mdd(dispatchable_object), msg_flags, (VkDbgObjectType) 0, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+                procs_txt.append('            reinterpret_cast<VkUintPtrLeast64>(object), string_VkDbgObjectType(objType));')
+            else:
+                procs_txt.append('        log_msg(mdd(dispatchable_object), msg_flags, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Unable to obtain status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+                procs_txt.append('            reinterpret_cast<VkUintPtrLeast64>(object.handle), string_VkDbgObjectType(objType));')
+            procs_txt.append('        return VK_FALSE;')
+            procs_txt.append('    }')
+            procs_txt.append('}')
+            procs_txt.append('')
+            procs_txt.append('%s' % self.lineinfo.get())
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('static void reset_status(%s dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o, o))
+                procs_txt.append('{')
+                procs_txt.append('    if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+                procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object];' % (o))
+            else:
+                procs_txt.append('static void reset_status(VkDevice dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o))
+                procs_txt.append('{')
+                procs_txt.append('    if (%sMap.find((void*)object.handle) != %sMap.end()) {' % (o, o))
+                procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[(void*)object.handle];' % (o))
+            procs_txt.append('        pNode->status &= ~status_flag;')
+            procs_txt.append('        return;')
+            procs_txt.append('    }')
+            procs_txt.append('    else {')
+            procs_txt.append('        // If we do not find it print an error')
+            if o in [ 'VkInstance', 'VkPhysicalDevice', 'VkDevice', 'VkQueue', 'VkCmdBuffer']:
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, reinterpret_cast<VkUintPtrLeast64>(object), 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Unable to reset status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+                procs_txt.append('            reinterpret_cast<VkUintPtrLeast64>(object), string_VkDbgObjectType(objType));')
+            else:
+                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, object.handle, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Unable to reset status for non-existent object 0x%" PRIxLEAST64 " of %s type",')
+                procs_txt.append('            reinterpret_cast<VkUintPtrLeast64>(object.handle), string_VkDbgObjectType(objType));')
+            procs_txt.append('    }')
+            procs_txt.append('}')
+            procs_txt.append('')
+        return "\n".join(procs_txt)
+
+    def generate_explicit_destroy_instance(self):
+        gedi_txt = []
+        gedi_txt.append('%s' % self.lineinfo.get())
+        gedi_txt.append('VkResult explicit_DestroyInstance(')
+        gedi_txt.append('VkInstance instance)')
+        gedi_txt.append('{')
+        gedi_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
+        gedi_txt.append('    validate_object(instance, instance);')
+        gedi_txt.append('')
+        gedi_txt.append('    destroy_obj(instance, instance);')
+        gedi_txt.append('    // Report any remaining objects in LL')
+        for o in vulkan.core.objects:
+            if o in ['VkPhysicalDevice', 'VkQueue']:
+                continue
+            gedi_txt.append('    for (auto it = %sMap.begin(); it != %sMap.end(); ++it) {' % (o, o))
+            gedi_txt.append('        OBJTRACK_NODE* pNode = it->second;')
+            gedi_txt.append('        log_msg(mid(instance), VK_DBG_REPORT_ERROR_BIT, pNode->objType, pNode->vkObj, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",')
+            gedi_txt.append('                "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDbgObjectType(pNode->objType),')
+            gedi_txt.append('                reinterpret_cast<VkUintPtrLeast64>(pNode->vkObj));')
+            gedi_txt.append('    }')
+            gedi_txt.append('')
+        gedi_txt.append('    dispatch_key key = get_dispatch_key(instance);')
+        gedi_txt.append('    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(ObjectTracker_instance_table_map, instance);')
+        gedi_txt.append('    VkResult result = pInstanceTable->DestroyInstance(instance);')
+        gedi_txt.append('')
+        gedi_txt.append('    // Clean up logging callback, if any')
+        gedi_txt.append('    layer_data *my_data = get_my_data_ptr(key, layer_data_map);')
+        gedi_txt.append('    if (my_data->logging_callback) {')
+        gedi_txt.append('        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);')
+        gedi_txt.append('    }')
+        gedi_txt.append('')
+        gedi_txt.append('    layer_debug_report_destroy_instance(mid(instance));')
+        gedi_txt.append('    layer_data_map.erase(pInstanceTable);')
+        gedi_txt.append('')
+        gedi_txt.append('    ObjectTracker_instance_table_map.erase(key);')
+        gedi_txt.append('    assert(ObjectTracker_instance_table_map.size() == 0 && "Should not have any instance mappings hanging around");')
+        gedi_txt.append('')
+        gedi_txt.append('    loader_platform_thread_unlock_mutex(&objLock);')
+        gedi_txt.append('    return result;')
+        gedi_txt.append('}')
+        gedi_txt.append('')
+        return "\n".join(gedi_txt)
+
+    def generate_explicit_destroy_device(self):
+        gedd_txt = []
+        gedd_txt.append('%s' % self.lineinfo.get())
+        gedd_txt.append('VkResult explicit_DestroyDevice(')
+        gedd_txt.append('VkDevice device)')
+        gedd_txt.append('{')
+        gedd_txt.append('    loader_platform_thread_lock_mutex(&objLock);')
+        gedd_txt.append('    validate_object(device, device);')
+        gedd_txt.append('')
+        gedd_txt.append('    destroy_obj(device, device);')
+        gedd_txt.append('    // Report any remaining objects in LL')
+        for o in vulkan.core.objects:
+            if o in ['VkPhysicalDevice', 'VkQueue']:
+                continue
+            gedd_txt.append('    for (auto it = %sMap.begin(); it != %sMap.end(); ++it) {' % (o, o))
+            gedd_txt.append('        OBJTRACK_NODE* pNode = it->second;')
+            gedd_txt.append('        log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, pNode->objType, pNode->vkObj, 0, OBJTRACK_OBJECT_LEAK, "OBJTRACK",')
+            gedd_txt.append('                "OBJ ERROR : %s object 0x%" PRIxLEAST64 " has not been destroyed.", string_VkDbgObjectType(pNode->objType),')
+            gedd_txt.append('                reinterpret_cast<VkUintPtrLeast64>(pNode->vkObj));')
+            gedd_txt.append('    }')
+            gedd_txt.append('')
+        gedd_txt.append("    // Clean up Queue's MemRef Linked Lists")
+        gedd_txt.append('    destroyQueueMemRefLists();')
+        gedd_txt.append('')
+        gedd_txt.append('    loader_platform_thread_unlock_mutex(&objLock);')
+        gedd_txt.append('')
+        gedd_txt.append('    dispatch_key key = get_dispatch_key(device);')
+        gedd_txt.append('    VkLayerDispatchTable *pDisp = get_dispatch_table(ObjectTracker_device_table_map, device);')
+        gedd_txt.append('    VkResult result = pDisp->DestroyDevice(device);')
+        gedd_txt.append('    ObjectTracker_device_table_map.erase(key);')
+        gedd_txt.append('    assert(ObjectTracker_device_table_map.size() == 0 && "Should not have any instance mappings hanging around");')
+        gedd_txt.append('')
+        gedd_txt.append('    return result;')
+        gedd_txt.append('}')
+        gedd_txt.append('')
+        return "\n".join(gedd_txt)
+
+    def generate_command_buffer_validates(self):
+        cbv_txt = []
+        cbv_txt.append('%s' % self.lineinfo.get())
+        for o in ['VkPipeline', 'VkDynamicViewportState', 'VkDynamicRasterState', 'VkDynamicColorBlendState', 'VkDynamicDepthStencilState',
+                  'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']:
+            cbv_txt.append('static void validate_object(VkCmdBuffer dispatchable_object, %s object)' % (o))
+            cbv_txt.append('{')
+            cbv_txt.append('    if (%sMap.find((void*)object.handle) == %sMap.end()) {' % (o, o))
+            cbv_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+            cbv_txt.append('            "Invalid Object %p",reinterpret_cast<VkUintPtrLeast64>(object.handle));')
+            cbv_txt.append('    }')
+            cbv_txt.append('}')
+            cbv_txt.append('')
+        return "\n".join(cbv_txt)
+
     def generate_intercept(self, proto, qual):
         if proto.name in [ 'DbgCreateMsgCallback', 'GetGlobalLayerProperties', 'GetGlobalExtensionProperties','GetPhysicalDeviceLayerProperties', 'GetPhysicalDeviceExtensionProperties' ]:
             # use default version
             return None
 
-        # Create map of object names to object type enums of the form VkName : VkDbgObjectTypeName
-        obj_type_mapping = {base_t : base_t.replace("Vk", "VkDbgObjectType") for base_t in vulkan.object_type_list}
+        # Create map of object names to object type enums of the form VkName : VkObjectTypeName
+        obj_type_mapping = {base_t : base_t.replace("Vk", "VkObjectType") for base_t in vulkan.object_type_list}
         # Convert object type enum names from UpperCamelCase to UPPER_CASE_WITH_UNDERSCORES
         for objectName, objectTypeEnum in obj_type_mapping.items():
             obj_type_mapping[objectName] = ucc_to_U_C_C(objectTypeEnum);
@@ -1068,8 +1368,6 @@ class ObjectTrackerSubcommand(Subcommand):
             "DestroyDevice",
             "GetDeviceQueue",
             "QueueSubmit",
-            "DestroyObject",
-            "GetObjectMemoryRequirements",
             "QueueBindSparseImageMemory",
             "QueueBindSparseBufferMemory",
             "GetFenceStatus",
@@ -1166,7 +1464,12 @@ class ObjectTrackerSubcommand(Subcommand):
         extensions=[('wsi_lunarg_enabled',
                     ['vkCreateSwapChainWSI', 'vkDestroySwapChainWSI',
                      'vkGetSwapChainInfoWSI', 'vkQueuePresentWSI'])]
-        body = [self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
+        body = [self.generate_maps(),
+                self.generate_procs(),
+                self.generate_explicit_destroy_instance(),
+                self.generate_explicit_destroy_device(),
+                self.generate_command_buffer_validates(),
+                self._generate_dispatch_entrypoints("VK_LAYER_EXPORT"),
                 self._generate_extensions(),
                 self._generate_layer_gpa_function(extensions,
                                                   instance_extensions=['msg_callback_get_proc_addr'])]
diff --git a/vulkan.py b/vulkan.py
index dbefac96..1f638f78 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -200,11 +200,9 @@ core = Extension(
         "VkAttachmentView",
         "VkShaderModule",
         "VkShader",
+        "VkPipelineCache",
         "VkPipelineLayout",
         "VkPipeline",
-        "VkPipelineCache",
-        "VkSampler",
-        "VkDescriptorSet",
         "VkDescriptorSetLayout",
         "VkSampler",
         "VkDescriptorPool",