diff --git a/include/vulkan.h b/include/vulkan.h
index 074f7e5..e17207b 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -44,46 +44,17 @@
 #define VK_API_VERSION VK_MAKE_VERSION(0, 185, 0)
 
 
-#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
-    #define VK_NULL_HANDLE nullptr
-#else
-    #define VK_NULL_HANDLE 0
-#endif
+#define VK_NULL_HANDLE 0
+        
 
 
 #define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj;
 
 
-#if defined(__cplusplus)
-    #if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
-        // The bool operator only works if there are no implicit conversions from an obj to
-        // a bool-compatible type, which can then be used to unintentionally violate type safety.
-        // C++11 and above supports the "explicit" keyword on conversion operators to stop this
-        // from happening. Otherwise users of C++ below C++11 won't get direct access to evaluating
-        // the object handle as a bool in expressions like:
-        //     if (obj) vkDestroy(obj);
-        #define VK_NONDISP_HANDLE_OPERATOR_BOOL() explicit operator bool() const { return handle != 0; }
-        #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
-            explicit obj(uint64_t x) : handle(x) { } \
-            obj(decltype(nullptr)) : handle(0) { }
-    #else
-        #define VK_NONDISP_HANDLE_OPERATOR_BOOL()
-        #define VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
-            obj(uint64_t x) : handle(x) { }
-    #endif
-    #define VK_DEFINE_NONDISP_HANDLE(obj) \
-        struct obj { \
-            obj() : handle(0) { } \
-            VK_NONDISP_HANDLE_CONSTRUCTOR_FROM_UINT64(obj) \
-            obj& operator =(uint64_t x) { handle = x; return *this; } \
-            bool operator==(const obj& other) const { return handle == other.handle; } \
-            bool operator!=(const obj& other) const { return handle != other.handle; } \
-            bool operator!() const { return !handle; } \
-            VK_NONDISP_HANDLE_OPERATOR_BOOL() \
-            uint64_t handle; \
-        };
+#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
+	#define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T *obj;
 #else
-    #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T { uint64_t handle; } obj;
+	#define VK_DEFINE_NONDISP_HANDLE(obj) typedef uint64_t obj;
 #endif
         
 
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index a928547..2b6d55e 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -63,21 +63,21 @@
     VkLayerInstanceDispatchTable* instance_dispatch_table;
     devExts device_extensions;
     // Layer specific data
-    unordered_map<uint64_t, unique_ptr<SAMPLER_NODE>> sampleMap;
-    unordered_map<uint64_t, unique_ptr<VkImageViewCreateInfo>> imageViewMap;
-    unordered_map<uint64_t, unique_ptr<VkImageCreateInfo>> imageMap;
-    unordered_map<uint64_t, unique_ptr<VkBufferViewCreateInfo>> bufferViewMap;
-    unordered_map<uint64_t, unique_ptr<VkBufferCreateInfo>> bufferMap;
-    unordered_map<uint64_t, PIPELINE_NODE*> pipelineMap;
-    unordered_map<uint64_t, POOL_NODE*> poolMap;
-    unordered_map<uint64_t, SET_NODE*> setMap;
-    unordered_map<uint64_t, LAYOUT_NODE*> layoutMap;
-    unordered_map<uint64_t, PIPELINE_LAYOUT_NODE> pipelineLayoutMap;
-    unordered_map<uint64_t, VkShaderStageFlagBits> shaderStageMap;
+    unordered_map<VkSampler, unique_ptr<SAMPLER_NODE>> sampleMap;
+    unordered_map<VkImageView, unique_ptr<VkImageViewCreateInfo>> imageViewMap;
+    unordered_map<VkImage, unique_ptr<VkImageCreateInfo>> imageMap;
+    unordered_map<VkBufferView, unique_ptr<VkBufferViewCreateInfo>> bufferViewMap;
+    unordered_map<VkBuffer, unique_ptr<VkBufferCreateInfo>> bufferMap;
+    unordered_map<VkPipeline, PIPELINE_NODE*> pipelineMap;
+    unordered_map<VkDescriptorPool, POOL_NODE*> poolMap;
+    unordered_map<VkDescriptorSet, SET_NODE*> setMap;
+    unordered_map<VkDescriptorSetLayout, LAYOUT_NODE*> layoutMap;
+    unordered_map<VkPipelineLayout, PIPELINE_LAYOUT_NODE> pipelineLayoutMap;
+    unordered_map<VkShader, VkShaderStageFlagBits> shaderStageMap;
     // Map for layout chains
     unordered_map<void*, GLOBAL_CB_NODE*> cmdBufferMap;
-    unordered_map<uint64_t, VkRenderPassCreateInfo*> renderPassMap;
-    unordered_map<uint64_t, VkFramebufferCreateInfo*> frameBufferMap;
+    unordered_map<VkRenderPass, VkRenderPassCreateInfo*> renderPassMap;
+    unordered_map<VkFramebuffer, VkFramebufferCreateInfo*> frameBufferMap;
 
     layer_data() :
         report_data(nullptr),
@@ -283,12 +283,12 @@
 static PIPELINE_NODE* getPipeline(layer_data* my_data, const VkPipeline pipeline)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    if (my_data->pipelineMap.find(pipeline.handle) == my_data->pipelineMap.end()) {
+    if (my_data->pipelineMap.find(pipeline) == my_data->pipelineMap.end()) {
         loader_platform_thread_unlock_mutex(&globalLock);
         return NULL;
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    return my_data->pipelineMap[pipeline.handle];
+    return my_data->pipelineMap[pipeline];
 }
 // Return VK_TRUE if for a given PSO, the given state enum is dynamic, else return VK_FALSE
 static VkBool32 isDynamic(const PIPELINE_NODE* pPipeline, const VkDynamicState state)
@@ -328,8 +328,8 @@
     //  We should have that check separately and then gate this check based on that check
     if (pPipe && (pCB->lastBoundPipelineLayout) && (pCB->lastBoundPipelineLayout != pPipe->graphicsPipelineCI.layout)) {
         result = VK_FALSE;
-        result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE_LAYOUT, pCB->lastBoundPipelineLayout.handle, 0, DRAWSTATE_PIPELINE_LAYOUT_MISMATCH, "DS",
-                "Pipeline layout from last vkCmdBindDescriptorSets() (%#" PRIxLEAST64 ") does not match PSO Pipeline layout (%#" PRIxLEAST64 ") ", pCB->lastBoundPipelineLayout.handle, pPipe->graphicsPipelineCI.layout.handle);
+        result |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE_LAYOUT, (uint64_t) pCB->lastBoundPipelineLayout, 0, DRAWSTATE_PIPELINE_LAYOUT_MISMATCH, "DS",
+                "Pipeline layout from last vkCmdBindDescriptorSets() (%#" PRIxLEAST64 ") does not match PSO Pipeline layout (%#" PRIxLEAST64 ") ", (uint64_t) pCB->lastBoundPipelineLayout, (uint64_t) pPipe->graphicsPipelineCI.layout);
     }
     // Verify Vtx binding
     if (MAX_BINDING != pCB->lastVtxBinding) {
@@ -449,10 +449,10 @@
     for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) {
         const VkPipelineShaderStageCreateInfo *pPSSCI = &pCreateInfo->pStages[i];
 
-        if (dev_data->shaderStageMap.find(pPSSCI->shader.handle) == dev_data->shaderStageMap.end())
+        if (dev_data->shaderStageMap.find(pPSSCI->shader) == dev_data->shaderStageMap.end())
             continue;
 
-        switch (dev_data->shaderStageMap[pPSSCI->shader.handle]) {
+        switch (dev_data->shaderStageMap[pPSSCI->shader]) {
             case VK_SHADER_STAGE_VERTEX_BIT:
                 memcpy(&pPipeline->vsCI, pPSSCI, sizeof(VkPipelineShaderStageCreateInfo));
                 pPipeline->active_shaders |= VK_SHADER_STAGE_VERTEX_BIT;
@@ -582,7 +582,7 @@
 // For given pipeline, return number of MSAA samples, or one if MSAA disabled
 static uint32_t getNumSamples(layer_data* my_data, const VkPipeline pipeline)
 {
-    PIPELINE_NODE* pPipe = my_data->pipelineMap[pipeline.handle];
+    PIPELINE_NODE* pPipe = my_data->pipelineMap[pipeline];
     if (VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO == pPipe->msStateCI.sType) {
         return pPipe->msStateCI.rasterSamples;
     }
@@ -595,7 +595,7 @@
         // Verify that any MSAA request in PSO matches sample# in bound FB
         uint32_t psoNumSamples = getNumSamples(my_data, pipeline);
         if (pCB->activeRenderPass) {
-            const VkRenderPassCreateInfo* pRPCI = my_data->renderPassMap[pCB->activeRenderPass.handle];
+            const VkRenderPassCreateInfo* pRPCI = my_data->renderPassMap[pCB->activeRenderPass];
             const VkSubpassDescription* pSD = &pRPCI->pSubpasses[pCB->activeSubpass];
             int subpassNumSamples = 0;
             uint32_t i;
@@ -623,9 +623,9 @@
             }
 
             if (psoNumSamples != subpassNumSamples) {
-                return log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
+                return log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline, 0, DRAWSTATE_NUM_SAMPLES_MISMATCH, "DS",
                         "Num samples mismatch! Binding PSO (%#" PRIxLEAST64 ") with %u samples while current RenderPass (%#" PRIxLEAST64 ") w/ %u samples!",
-                        pipeline.handle, psoNumSamples, pCB->activeRenderPass.handle, subpassNumSamples);
+                        (uint64_t) pipeline, psoNumSamples, (uint64_t) pCB->activeRenderPass, subpassNumSamples);
             }
         } else {
             // TODO : I believe it's an error if we reach this point and don't have an activeRenderPass
@@ -644,33 +644,33 @@
 static POOL_NODE* getPoolNode(layer_data* my_data, const VkDescriptorPool pool)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    if (my_data->poolMap.find(pool.handle) == my_data->poolMap.end()) {
+    if (my_data->poolMap.find(pool) == my_data->poolMap.end()) {
         loader_platform_thread_unlock_mutex(&globalLock);
         return NULL;
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    return my_data->poolMap[pool.handle];
+    return my_data->poolMap[pool];
 }
 // Return Set node ptr for specified set or else NULL
 static SET_NODE* getSetNode(layer_data* my_data, const VkDescriptorSet set)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    if (my_data->setMap.find(set.handle) == my_data->setMap.end()) {
+    if (my_data->setMap.find(set) == my_data->setMap.end()) {
         loader_platform_thread_unlock_mutex(&globalLock);
         return NULL;
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    return my_data->setMap[set.handle];
+    return my_data->setMap[set];
 }
 
 static LAYOUT_NODE* getLayoutNode(layer_data* my_data, const VkDescriptorSetLayout layout) {
     loader_platform_thread_lock_mutex(&globalLock);
-    if (my_data->layoutMap.find(layout.handle) == my_data->layoutMap.end()) {
+    if (my_data->layoutMap.find(layout) == my_data->layoutMap.end()) {
         loader_platform_thread_unlock_mutex(&globalLock);
         return NULL;
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    return my_data->layoutMap[layout.handle];
+    return my_data->layoutMap[layout];
 }
 // Return VK_FALSE if update struct is of valid type, otherwise flag error and return code from callback
 static VkBool32 validUpdateStruct(layer_data* my_data, const VkDevice device, const GENERIC_HEADER* pUpdateStruct)
@@ -836,14 +836,14 @@
 static VkBool32 validateSampler(const layer_data* my_data, const VkSampler* pSampler, const VkBool32 immutable)
 {
     VkBool32 skipCall = VK_FALSE;
-    auto sampIt = my_data->sampleMap.find(pSampler->handle);
+    auto sampIt = my_data->sampleMap.find(*pSampler);
     if (sampIt == my_data->sampleMap.end()) {
         if (!immutable) {
-            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
-                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid sampler %#" PRIxLEAST64, pSampler->handle);
+            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
+                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid sampler %#" PRIxLEAST64, (uint64_t) *pSampler);
         } else { // immutable
-            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
-                "vkUpdateDescriptorSets: Attempt to update descriptor whose binding has an invalid immutable sampler %#" PRIxLEAST64, pSampler->handle);
+            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_SAMPLER_DESCRIPTOR_ERROR, "DS",
+                "vkUpdateDescriptorSets: Attempt to update descriptor whose binding has an invalid immutable sampler %#" PRIxLEAST64, (uint64_t) *pSampler);
         }
     } else {
         // TODO : Any further checks we want to do on the sampler?
@@ -854,19 +854,19 @@
 static VkBool32 validateImageView(const layer_data* my_data, const VkImageView* pImageView, const VkImageLayout imageLayout)
 {
     VkBool32 skipCall = VK_FALSE;
-    auto ivIt = my_data->imageViewMap.find(pImageView->handle);
+    auto ivIt = my_data->imageViewMap.find(*pImageView);
     if (ivIt == my_data->imageViewMap.end()) {
-        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
-                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid imageView %#" PRIxLEAST64, pImageView->handle);
+        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
+                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid imageView %#" PRIxLEAST64, (uint64_t) *pImageView);
     } else {
         // Validate that imageLayout is compatible with aspectMask and image format
         VkImageAspectFlags aspectMask = ivIt->second->subresourceRange.aspectMask;
-        uint64_t imageHandle = ivIt->second->image.handle;
+        VkImage image = ivIt->second->image;
         // TODO : Check here in case we have a bad image handle
-        auto imgIt = my_data->imageMap.find(imageHandle);
+        auto imgIt = my_data->imageMap.find(image);
         if (imgIt == my_data->imageMap.end()) {
-            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, imageHandle, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
-                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid image handle %#" PRIxLEAST64 " in imageView %#" PRIxLEAST64, imageHandle, pImageView->handle);
+            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) image, 0, DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS",
+                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid image handle %#" PRIxLEAST64 " in imageView %#" PRIxLEAST64, (uint64_t) image, (uint64_t) *pImageView);
         } else {
             VkFormat format = (*imgIt).second->format;
             bool ds = vk_format_is_depth_or_stencil(format);
@@ -874,15 +874,15 @@
                 case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
                     // Only Color bit must be set
                     if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) {
-                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
                             DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL and imageView %#" PRIxLEAST64 ""
-                                    " that does not have VK_IMAGE_ASPECT_COLOR_BIT set.", pImageView->handle);
+                                    " that does not have VK_IMAGE_ASPECT_COLOR_BIT set.", (uint64_t) *pImageView);
                     }
                     // format must NOT be DS
                     if (ds) {
-                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
                             DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL and imageView %#" PRIxLEAST64 ""
-                                    " but the image format is %s which is not a color format.", pImageView->handle, string_VkFormat(format));
+                                    " but the image format is %s which is not a color format.", (uint64_t) *pImageView, string_VkFormat(format));
                     }
                     break;
                 case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
@@ -891,21 +891,21 @@
                     if (aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) {
                         if (aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) {
                             // both  must NOT be set
-                            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+                            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
                             DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with imageView %#" PRIxLEAST64 ""
-                                    " that has both STENCIL and DEPTH aspects set", pImageView->handle);
+                                    " that has both STENCIL and DEPTH aspects set", (uint64_t) *pImageView);
                         }
                     } else if (!(aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT)) {
                         // Neither were set
-                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
                             DRAWSTATE_INVALID_IMAGE_ASPECT, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout %s and imageView %#" PRIxLEAST64 ""
-                                    " that does not have STENCIL or DEPTH aspect set.", string_VkImageLayout(imageLayout), pImageView->handle);
+                                    " that does not have STENCIL or DEPTH aspect set.", string_VkImageLayout(imageLayout), (uint64_t) *pImageView);
                     }
                     // format must be DS
                     if (!ds) {
-                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, pImageView->handle, 0,
+                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE_VIEW, (uint64_t) *pImageView, 0,
                             DRAWSTATE_IMAGEVIEW_DESCRIPTOR_ERROR, "DS", "vkUpdateDescriptorSets: Updating descriptor with layout %s and imageView %#" PRIxLEAST64 ""
-                                    " but the image format is %s which is not a depth/stencil format.", string_VkImageLayout(imageLayout), pImageView->handle, string_VkFormat(format));
+                                    " but the image format is %s which is not a depth/stencil format.", string_VkImageLayout(imageLayout), (uint64_t) *pImageView, string_VkFormat(format));
                     }
                     break;
                 default:
@@ -920,10 +920,10 @@
 static VkBool32 validateBufferView(const layer_data* my_data, const VkBufferView* pBufferView)
 {
     VkBool32 skipCall = VK_FALSE;
-    auto sampIt = my_data->bufferViewMap.find(pBufferView->handle);
+    auto sampIt = my_data->bufferViewMap.find(*pBufferView);
     if (sampIt == my_data->bufferViewMap.end()) {
-        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER_VIEW, pBufferView->handle, 0, DRAWSTATE_BUFFERVIEW_DESCRIPTOR_ERROR, "DS",
-                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid bufferView %#" PRIxLEAST64, pBufferView->handle);
+        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER_VIEW, (uint64_t) *pBufferView, 0, DRAWSTATE_BUFFERVIEW_DESCRIPTOR_ERROR, "DS",
+                "vkUpdateDescriptorSets: Attempt to update descriptor with invalid bufferView %#" PRIxLEAST64, (uint64_t) *pBufferView);
     } else {
         // TODO : Any further checks we want to do on the bufferView?
     }
@@ -933,10 +933,10 @@
 static VkBool32 validateBufferInfo(const layer_data* my_data, const VkDescriptorBufferInfo* pBufferInfo)
 {
     VkBool32 skipCall = VK_FALSE;
-    auto sampIt = my_data->bufferMap.find(pBufferInfo->buffer.handle);
+    auto sampIt = my_data->bufferMap.find(pBufferInfo->buffer);
     if (sampIt == my_data->bufferMap.end()) {
-        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, pBufferInfo->buffer.handle, 0, DRAWSTATE_BUFFERINFO_DESCRIPTOR_ERROR, "DS",
-                "vkUpdateDescriptorSets: Attempt to update descriptor where bufferInfo has invalid buffer %#" PRIxLEAST64, pBufferInfo->buffer.handle);
+        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_BUFFER, (uint64_t) pBufferInfo->buffer, 0, DRAWSTATE_BUFFERINFO_DESCRIPTOR_ERROR, "DS",
+                "vkUpdateDescriptorSets: Attempt to update descriptor where bufferInfo has invalid buffer %#" PRIxLEAST64, (uint64_t) pBufferInfo->buffer);
     } else {
         // TODO : Any further checks we want to do on the bufferView?
     }
@@ -965,14 +965,14 @@
                 if (NULL == pLayoutBinding->pImmutableSamplers) {
                     pSampler = &(pWDS->pImageInfo[i].sampler);
                     if (immutable) {
-                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
+                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
                             "vkUpdateDescriptorSets: Update #%u is not an immutable sampler %#" PRIxLEAST64 ", but previous update(s) from this "
                             "VkWriteDescriptorSet struct used an immutable sampler. All updates from a single struct must either "
-                            "use immutable or non-immutable samplers.", i, pSampler->handle);
+                            "use immutable or non-immutable samplers.", i, (uint64_t) *pSampler);
                     }
                 } else {
                     if (i>0 && !immutable) {
-                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, pSampler->handle, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
+                        skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SAMPLER, (uint64_t) *pSampler, 0, DRAWSTATE_INCONSISTENT_IMMUTABLE_SAMPLER_UPDATE, "DS",
                             "vkUpdateDescriptorSets: Update #%u is an immutable sampler, but previous update(s) from this "
                             "VkWriteDescriptorSet struct used a non-immutable sampler. All updates from a single struct must either "
                             "use immutable or non-immutable samplers.", i);
@@ -1019,7 +1019,7 @@
     uint32_t i = 0;
     for (i=0; i < writeCount; i++) {
         VkDescriptorSet ds = pWDS[i].destSet;
-        SET_NODE* pSet = my_data->setMap[ds.handle];
+        SET_NODE* pSet = my_data->setMap[ds];
         GENERIC_HEADER* pUpdate = (GENERIC_HEADER*) &pWDS[i];
         pLayout = pSet->pLayout;
         // First verify valid update struct
@@ -1030,7 +1030,7 @@
         binding = pWDS[i].destBinding;
         // Make sure that layout being updated has the binding being updated
         if (pLayout->createInfo.count < binding) {
-            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
+            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                     "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, binding, string_VkStructureType(pUpdate->sType));
         } else {
             // Next verify that update falls within size of given binding
@@ -1038,7 +1038,7 @@
             if (getBindingEndIndex(pLayout, binding) < endIndex) {
                 pLayoutCI = &pLayout->createInfo;
                 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS}    ");
-                skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
+                skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
                         "Descriptor update type of %s is out of bounds for matching binding %u in Layout w/ CI:\n%s!", string_VkStructureType(pUpdate->sType), binding, DSstr.c_str());
             } else { // TODO : should we skip update on a type mismatch or force it?
                 uint32_t startIndex;
@@ -1052,7 +1052,7 @@
                         GENERIC_HEADER* pNewNode = NULL;
                         skipCall |= shadowUpdateNode(my_data, device, pUpdate, &pNewNode);
                         if (NULL == pNewNode) {
-                            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, ds.handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+                            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
                                     "Out of memory while attempting to allocate UPDATE struct in vkUpdateDescriptors()");
                         } else {
                             // Insert shadow node into LL of updates for this set
@@ -1075,19 +1075,19 @@
         LAYOUT_NODE *pSrcLayout = NULL, *pDstLayout = NULL;
         uint32_t srcStartIndex = 0, srcEndIndex = 0, dstStartIndex = 0, dstEndIndex = 0;
         // For each copy make sure that update falls within given layout and that types match
-        pSrcSet = my_data->setMap[pCDS[i].srcSet.handle];
-        pDstSet = my_data->setMap[pCDS[i].destSet.handle];
+        pSrcSet = my_data->setMap[pCDS[i].srcSet];
+        pDstSet = my_data->setMap[pCDS[i].destSet];
         pSrcLayout = pSrcSet->pLayout;
         pDstLayout = pDstSet->pLayout;
         // Validate that src binding is valid for src set layout
         if (pSrcLayout->createInfo.count < pCDS[i].srcBinding) {
-            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pSrcSet->set.handle, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
+            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                 "Copy descriptor update %u has srcBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
-                i, pCDS[i].srcBinding, pSrcLayout->layout.handle, pSrcLayout->createInfo.count-1);
+                i, pCDS[i].srcBinding, (uint64_t) pSrcLayout->layout, pSrcLayout->createInfo.count-1);
         } else if (pDstLayout->createInfo.count < pCDS[i].destBinding) {
-            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDstSet->set.handle, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
+            skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                 "Copy descriptor update %u has destBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
-                i, pCDS[i].destBinding, pDstLayout->layout.handle, pDstLayout->createInfo.count-1);
+                i, pCDS[i].destBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.count-1);
         } else {
             // Proceed with validation. Bindings are ok, but make sure update is within bounds of given layout
             srcEndIndex = getUpdateEndIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
@@ -1095,12 +1095,12 @@
             if (getBindingEndIndex(pSrcLayout, pCDS[i].srcBinding) < srcEndIndex) {
                 pLayoutCI = &pSrcLayout->createInfo;
                 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS}    ");
-                skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pSrcSet->set.handle, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
+                skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
                     "Copy descriptor src update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].srcBinding, DSstr.c_str());
             } else if (getBindingEndIndex(pDstLayout, pCDS[i].destBinding) < dstEndIndex) {
                 pLayoutCI = &pDstLayout->createInfo;
                 string DSstr = vk_print_vkdescriptorsetlayoutcreateinfo(pLayoutCI, "{DS}    ");
-                skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDstSet->set.handle, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
+                skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_DESCRIPTOR_UPDATE_OUT_OF_BOUNDS, "DS",
                     "Copy descriptor dest update is out of bounds for matching binding %u in Layout w/ CI:\n%s!", pCDS[i].destBinding, DSstr.c_str());
             } else {
                 srcStartIndex = getUpdateStartIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
@@ -1130,17 +1130,17 @@
     for (i=0; i<count; ++i) {
         LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pSetLayouts[i]);
         if (NULL == pLayout) {
-            skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pSetLayouts[i].handle, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
-                    "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pSetLayouts[i].handle);
+            skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
+                    "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pSetLayouts[i]);
         } else {
             uint32_t typeIndex = 0, typeCount = 0;
             for (j=0; j<pLayout->createInfo.count; ++j) {
                 typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBinding[j].descriptorType);
                 typeCount = pLayout->createInfo.pBinding[j].arraySize;
                 if (typeCount > pPoolNode->availableDescriptorTypeCount[typeIndex]) {
-                    skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pLayout->layout.handle, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS",
+                    skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pLayout->layout, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS",
                         "Unable to allocate %u descriptors of type %s from pool %#" PRIxLEAST64 ". This pool only has %u descriptors of this type remaining.",
-                            typeCount, string_VkDescriptorType(pLayout->createInfo.pBinding[j].descriptorType), pPoolNode->pool.handle, pPoolNode->availableDescriptorTypeCount[typeIndex]);
+                            typeCount, string_VkDescriptorType(pLayout->createInfo.pBinding[j].descriptorType), (uint64_t) pPoolNode->pool, pPoolNode->availableDescriptorTypeCount[typeIndex]);
                 } else { // Decrement available descriptors of this type
                     pPoolNode->availableDescriptorTypeCount[typeIndex] -= typeCount;
                 }
@@ -1249,8 +1249,8 @@
 {
     POOL_NODE* pPool = getPoolNode(my_data, pool);
     if (!pPool) {
-        log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
-                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkResetDescriptorPool() call", pool.handle);
+        log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pool, 0, DRAWSTATE_INVALID_POOL, "DS",
+                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkResetDescriptorPool() call", (uint64_t) pool);
     } else {
         // TODO: validate flags
         // For every set off of this pool, clear it
@@ -1422,7 +1422,7 @@
         POOL_NODE* pPool = getPoolNode(my_data, pSet->pool);
         // Print out pool details
         skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
-                "Details for pool %#" PRIxLEAST64 ".", pPool->pool.handle);
+                "Details for pool %#" PRIxLEAST64 ".", (uint64_t) pPool->pool);
         string poolStr = vk_print_vkdescriptorpoolcreateinfo(&pPool->createInfo, " ");
         skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
                 "%s", poolStr.c_str());
@@ -1430,11 +1430,11 @@
         char prefix[10];
         uint32_t index = 0;
         skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
-                "Details for descriptor set %#" PRIxLEAST64 ".", pSet->set.handle);
+                "Details for descriptor set %#" PRIxLEAST64 ".", (uint64_t) pSet->set);
         LAYOUT_NODE* pLayout = pSet->pLayout;
         // Print layout details
         skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
-                "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, (void*)pLayout->layout.handle, (void*)pSet->set.handle);
+                "Layout #%u, (object %#" PRIxLEAST64 ") for DS %#" PRIxLEAST64 ".", index+1, (void*)pLayout->layout, (void*)pSet->set);
         sprintf(prefix, "  [L%u] ", index);
         string DSLstr = vk_print_vkdescriptorsetlayoutcreateinfo(&pLayout->createInfo, prefix).c_str();
         skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
@@ -1443,7 +1443,7 @@
         GENERIC_HEADER* pUpdate = pSet->pUpdateStructs;
         if (pUpdate) {
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
-                    "Update Chain [UC] for descriptor set %#" PRIxLEAST64 ":", pSet->set.handle);
+                    "Update Chain [UC] for descriptor set %#" PRIxLEAST64 ":", (uint64_t) pSet->set);
             sprintf(prefix, "  [UC] ");
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
                     dynamic_display(pUpdate, prefix).c_str());
@@ -1451,10 +1451,10 @@
         } else {
             if (0 != pSet->descriptorCount) {
                 skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
-                        "No Update Chain for descriptor set %#" PRIxLEAST64 " which has %u descriptors (vkUpdateDescriptors has not been called)", pSet->set.handle, pSet->descriptorCount);
+                        "No Update Chain for descriptor set %#" PRIxLEAST64 " which has %u descriptors (vkUpdateDescriptors has not been called)", (uint64_t) pSet->set, pSet->descriptorCount);
             } else {
                 skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_INFO_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NONE, "DS",
-                        "FYI: No descriptors in descriptor set %#" PRIxLEAST64 ".", pSet->set.handle);
+                        "FYI: No descriptors in descriptor set %#" PRIxLEAST64 ".", (uint64_t) pSet->set);
             }
         }
     }
@@ -1498,7 +1498,7 @@
         inside = log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
                          (uint64_t)pCB->cmdBuffer, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
                          "%s: It is invalid to issue this call inside an active render pass (%#" PRIxLEAST64 ")",
-                         apiName, pCB->activeRenderPass.handle);
+                         apiName, (uint64_t) pCB->activeRenderPass);
     }
     return inside;
 }
@@ -1767,25 +1767,22 @@
 VK_LAYER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    uint64_t handle = buffer.handle;
     dev_data->device_dispatch_table->DestroyBuffer(device, buffer);
-    dev_data->bufferMap.erase(handle);
+    dev_data->bufferMap.erase(buffer);
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    uint64_t handle = bufferView.handle;
     dev_data->device_dispatch_table->DestroyBufferView(device, bufferView);
-    dev_data->bufferViewMap.erase(handle);
+    dev_data->bufferViewMap.erase(bufferView);
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    uint64_t handle = image.handle;
     dev_data->device_dispatch_table->DestroyImage(device, image);
-    dev_data->imageMap.erase(handle);
+    dev_data->imageMap.erase(image);
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
@@ -1803,9 +1800,8 @@
 VK_LAYER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
 {
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    uint64_t handle = shader.handle;
     dev_data->device_dispatch_table->DestroyShader(device, shader);
-    dev_data->shaderStageMap.erase(handle);
+    dev_data->shaderStageMap.erase(shader);
 }
 
 VK_LAYER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
@@ -1863,7 +1859,7 @@
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         // 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->handle] = unique_ptr<VkBufferCreateInfo>(new VkBufferCreateInfo(*pCreateInfo));
+        dev_data->bufferMap[*pBuffer] = unique_ptr<VkBufferCreateInfo>(new VkBufferCreateInfo(*pCreateInfo));
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -1875,7 +1871,7 @@
     VkResult result = dev_data->device_dispatch_table->CreateBufferView(device, pCreateInfo, pView);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        dev_data->bufferViewMap[pView->handle] = unique_ptr<VkBufferViewCreateInfo>(new VkBufferViewCreateInfo(*pCreateInfo));
+        dev_data->bufferViewMap[*pView] = unique_ptr<VkBufferViewCreateInfo>(new VkBufferViewCreateInfo(*pCreateInfo));
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -1887,7 +1883,7 @@
     VkResult result = dev_data->device_dispatch_table->CreateImage(device, pCreateInfo, pImage);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        dev_data->imageMap[pImage->handle] = unique_ptr<VkImageCreateInfo>(new VkImageCreateInfo(*pCreateInfo));
+        dev_data->imageMap[*pImage] = unique_ptr<VkImageCreateInfo>(new VkImageCreateInfo(*pCreateInfo));
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -1899,7 +1895,7 @@
     VkResult result = dev_data->device_dispatch_table->CreateImageView(device, pCreateInfo, pView);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        dev_data->imageViewMap[pView->handle] = unique_ptr<VkImageViewCreateInfo>(new VkImageViewCreateInfo(*pCreateInfo));
+        dev_data->imageViewMap[*pView] = unique_ptr<VkImageViewCreateInfo>(new VkImageViewCreateInfo(*pCreateInfo));
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -1915,7 +1911,7 @@
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        dev_data->shaderStageMap[pShader->handle] = pCreateInfo->stage;
+        dev_data->shaderStageMap[*pShader] = pCreateInfo->stage;
         loader_platform_thread_unlock_mutex(&globalLock);
     }
 
@@ -1987,7 +1983,7 @@
         loader_platform_thread_lock_mutex(&globalLock);
         for (i=0; i<count; i++) {
             pPipeNode[i]->pipeline = pPipelines[i];
-            dev_data->pipelineMap[pPipeNode[i]->pipeline.handle] = pPipeNode[i];
+            dev_data->pipelineMap[pPipeNode[i]->pipeline] = pPipeNode[i];
         }
         loader_platform_thread_unlock_mutex(&globalLock);
     } else {
@@ -2011,7 +2007,7 @@
     VkResult result = dev_data->device_dispatch_table->CreateSampler(device, pCreateInfo, pSampler);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        dev_data->sampleMap[pSampler->handle] = unique_ptr<SAMPLER_NODE>(new SAMPLER_NODE(pSampler, pCreateInfo));
+        dev_data->sampleMap[*pSampler] = unique_ptr<SAMPLER_NODE>(new SAMPLER_NODE(pSampler, pCreateInfo));
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -2024,7 +2020,7 @@
     if (VK_SUCCESS == result) {
         LAYOUT_NODE* pNewNode = new LAYOUT_NODE;
         if (NULL == pNewNode) {
-            if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (*pSetLayout).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+            if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) *pSetLayout, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
                     "Out of memory while attempting to allocate LAYOUT_NODE in vkCreateDescriptorSetLayout()"))
                 return VK_ERROR_VALIDATION_FAILED;
         }
@@ -2060,7 +2056,7 @@
         assert(pNewNode->endIndex >= pNewNode->startIndex);
         // Put new node at Head of global Layer list
         loader_platform_thread_lock_mutex(&globalLock);
-        dev_data->layoutMap[pSetLayout->handle] = pNewNode;
+        dev_data->layoutMap[*pSetLayout] = pNewNode;
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -2071,7 +2067,7 @@
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
     if (VK_SUCCESS == result) {
-        PIPELINE_LAYOUT_NODE plNode = dev_data->pipelineLayoutMap[pPipelineLayout->handle];
+        PIPELINE_LAYOUT_NODE plNode = dev_data->pipelineLayoutMap[*pPipelineLayout];
         plNode.descriptorSetLayouts.resize(pCreateInfo->descriptorSetCount);
         uint32_t i = 0;
         for (i=0; i<pCreateInfo->descriptorSetCount; ++i) {
@@ -2091,17 +2087,17 @@
     VkResult result = dev_data->device_dispatch_table->CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
     if (VK_SUCCESS == result) {
         // Insert this pool into Global Pool LL at head
-        if (log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (*pDescriptorPool).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
-                "Created Descriptor Pool %#" PRIxLEAST64, (*pDescriptorPool).handle))
+        if (log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+                "Created Descriptor Pool %#" PRIxLEAST64, (uint64_t) *pDescriptorPool))
             return VK_ERROR_VALIDATION_FAILED;
         loader_platform_thread_lock_mutex(&globalLock);
         POOL_NODE* pNewNode = new POOL_NODE(*pDescriptorPool, pCreateInfo);
         if (NULL == pNewNode) {
-            if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (*pDescriptorPool).handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+            if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) *pDescriptorPool, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
                     "Out of memory while attempting to allocate POOL_NODE in vkCreateDescriptorPool()"))
                 return VK_ERROR_VALIDATION_FAILED;
         } else {
-            dev_data->poolMap[pDescriptorPool->handle] = pNewNode;
+            dev_data->poolMap[*pDescriptorPool] = pNewNode;
         }
         loader_platform_thread_unlock_mutex(&globalLock);
     } else {
@@ -2127,8 +2123,8 @@
     // Verify that requested descriptorSets are available in pool
     POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
     if (!pPoolNode) {
-        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, pAllocInfo->descriptorPool.handle, 0, DRAWSTATE_INVALID_POOL, "DS",
-                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pAllocInfo->descriptorPool.handle);
+        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
+                "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->descriptorPool);
     } else { // Make sure pool has all the available descriptors before calling down chain
         skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocInfo->count, pAllocInfo->pSetLayouts);
     }
@@ -2143,12 +2139,12 @@
                         "AllocDescriptorSets called with 0 count");
             }
             for (uint32_t i = 0; i < pAllocInfo->count; i++) {
-                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_NONE, "DS",
-                        "Created Descriptor Set %#" PRIxLEAST64, pDescriptorSets[i].handle);
+                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
+                        "Created Descriptor Set %#" PRIxLEAST64, (uint64_t) pDescriptorSets[i]);
                 // Create new set node and add to head of pool nodes
                 SET_NODE* pNewNode = new SET_NODE;
                 if (NULL == pNewNode) {
-                    if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
+                    if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_OUT_OF_MEMORY, "DS",
                             "Out of memory while attempting to allocate SET_NODE in vkAllocDescriptorSets()"))
                         return VK_ERROR_VALIDATION_FAILED;
                 } else {
@@ -2161,8 +2157,8 @@
                     pPoolNode->pSets = pNewNode;
                     LAYOUT_NODE* pLayout = getLayoutNode(dev_data, pAllocInfo->pSetLayouts[i]);
                     if (NULL == pLayout) {
-                        if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, pAllocInfo->pSetLayouts[i].handle, 0, DRAWSTATE_INVALID_LAYOUT, "DS",
-                                "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", pAllocInfo->pSetLayouts[i].handle))
+                        if (log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pAllocInfo->pSetLayouts[i], 0, DRAWSTATE_INVALID_LAYOUT, "DS",
+                                "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->pSetLayouts[i]))
                             return VK_ERROR_VALIDATION_FAILED;
                     }
                     pNewNode->pLayout = pLayout;
@@ -2174,7 +2170,7 @@
                         pNewNode->ppDescriptors = new GENERIC_HEADER*[descriptorArraySize];
                         memset(pNewNode->ppDescriptors, 0, descriptorArraySize);
                     }
-                    dev_data->setMap[pDescriptorSets[i].handle] = pNewNode;
+                    dev_data->setMap[pDescriptorSets[i]] = pNewNode;
                 }
             }
         }
@@ -2198,7 +2194,7 @@
     if (VK_SUCCESS == result) {
         // For each freed descriptor add it back into the pool as available
         for (uint32_t i=0; i<count; ++i) {
-            SET_NODE* pSet = dev_data->setMap[pDescriptorSets[i].handle]; // getSetNode() without locking
+            SET_NODE* pSet = dev_data->setMap[pDescriptorSets[i]]; // getSetNode() without locking
             LAYOUT_NODE* pLayout = pSet->pLayout;
             uint32_t typeIndex = 0, typeCount = 0;
             for (uint32_t j=0; j<pLayout->createInfo.count; ++j) {
@@ -2248,13 +2244,13 @@
     GLOBAL_CB_NODE* pCB = getCBNode(dev_data, cmdBuffer);
     if (pCB) {
         if (pCB->level == VK_CMD_BUFFER_LEVEL_PRIMARY) {
-            if (pBeginInfo->renderPass.handle || pBeginInfo->framebuffer.handle) {
+            if (pBeginInfo->renderPass || pBeginInfo->framebuffer) {
                 // These should be NULL for a Primary CB
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
                     "vkAllocCommandBuffers():  Primary Command Buffer (%p) may not specify framebuffer or renderpass parameters", (void*)cmdBuffer);
             }
         } else {
-            if (!pBeginInfo->renderPass.handle || !pBeginInfo->framebuffer.handle) {
+            if (!pBeginInfo->renderPass || !pBeginInfo->framebuffer) {
                 // These should NOT be null for an Secondary CB
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, 0, 0, DRAWSTATE_BEGIN_CB_INVALID_STATE, "DS",
                     "vkAllocCommandBuffers():  Secondary Command Buffers (%p) must specify framebuffer and renderpass parameters", (void*)cmdBuffer);
@@ -2327,14 +2323,14 @@
             updateCBTracking(pCB);
             skipCall |= addCmd(dev_data, pCB, CMD_BINDPIPELINE);
             if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
-                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
+                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline,
                                     0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
                                     "Incorrectly binding compute pipeline (%#" PRIxLEAST64 ") during active RenderPass (%#" PRIxLEAST64 ")",
-                                    pipeline.handle, pCB->activeRenderPass.handle);
+                                    (uint64_t) pipeline, (uint64_t) pCB->activeRenderPass);
             } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
-                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
+                skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline,
                                     0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS", "Incorrectly binding graphics pipeline "
-                                    " (%#" PRIxLEAST64 ") without an active RenderPass", pipeline.handle);
+                                    " (%#" PRIxLEAST64 ") without an active RenderPass", (uint64_t) pipeline);
             } else {
                 PIPELINE_NODE* pPN = getPipeline(dev_data, pipeline);
                 if (pPN) {
@@ -2345,9 +2341,9 @@
                     loader_platform_thread_unlock_mutex(&globalLock);
                     skipCall |= validatePipelineState(dev_data, pCB, pipelineBindPoint, pipeline);
                 } else {
-                    skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline.handle,
+                    skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, (uint64_t) pipeline,
                                         0, DRAWSTATE_INVALID_PIPELINE, "DS",
-                                        "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", (void*)pipeline.handle);
+                                        "Attempt to bind Pipeline %#" PRIxLEAST64 " that doesn't exist!", (void*)pipeline);
                 }
             }
         } else {
@@ -2595,7 +2591,7 @@
         if (pCB->state == CB_UPDATE_ACTIVE) {
             if ((VK_PIPELINE_BIND_POINT_COMPUTE == pipelineBindPoint) && (pCB->activeRenderPass)) {
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_INVALID_RENDERPASS_CMD, "DS",
-                        "Incorrectly binding compute DescriptorSets during active RenderPass (%#" PRIxLEAST64 ")", pCB->activeRenderPass.handle);
+                        "Incorrectly binding compute DescriptorSets during active RenderPass (%#" PRIxLEAST64 ")", (uint64_t) pCB->activeRenderPass);
             } else if ((VK_PIPELINE_BIND_POINT_GRAPHICS == pipelineBindPoint) && (!pCB->activeRenderPass)) {
                 skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_NO_ACTIVE_RENDERPASS, "DS",
                         "Incorrectly binding graphics DescriptorSets without an active RenderPass");
@@ -2608,14 +2604,14 @@
                         pCB->lastBoundPipelineLayout = layout;
                         pCB->boundDescriptorSets.push_back(pDescriptorSets[i]);
                         loader_platform_thread_unlock_mutex(&globalLock);
-                        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_NONE, "DS",
-                                "DS %#" PRIxLEAST64 " bound on pipeline %s", pDescriptorSets[i].handle, string_VkPipelineBindPoint(pipelineBindPoint));
+                        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
+                                "DS %#" PRIxLEAST64 " bound on pipeline %s", (uint64_t) pDescriptorSets[i], string_VkPipelineBindPoint(pipelineBindPoint));
                         if (!pSet->pUpdateStructs)
-                            skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS",
-                                    "DS %#" PRIxLEAST64 " bound but it was never updated. You may want to either update it or not bind it.", pDescriptorSets[i].handle);
+                            skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_DESCRIPTOR_SET_NOT_UPDATED, "DS",
+                                    "DS %#" PRIxLEAST64 " bound but it was never updated. You may want to either update it or not bind it.", (uint64_t) pDescriptorSets[i]);
                     } else {
-                        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pDescriptorSets[i].handle, 0, DRAWSTATE_INVALID_SET, "DS",
-                                "Attempt to bind DS %#" PRIxLEAST64 " that doesn't exist!", pDescriptorSets[i].handle);
+                        skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_INVALID_SET, "DS",
+                                "Attempt to bind DS %#" PRIxLEAST64 " that doesn't exist!", (uint64_t) pDescriptorSets[i]);
                     }
                 }
                 updateCBTracking(pCB);
@@ -2997,7 +2993,7 @@
 
     // Validate that attachment is in reference list of active subpass
     if (pCB->activeRenderPass) {
-        const VkRenderPassCreateInfo *pRPCI = dev_data->renderPassMap[pCB->activeRenderPass.handle];
+        const VkRenderPassCreateInfo *pRPCI = dev_data->renderPassMap[pCB->activeRenderPass];
         const VkSubpassDescription   *pSD   = &pRPCI->pSubpasses[pCB->activeSubpass];
 
         for (uint32_t attachment_idx = 0; attachment_idx < attachmentCount; attachment_idx++) {
@@ -3268,7 +3264,7 @@
             localFBCI->pAttachments = new VkImageView[localFBCI->attachmentCount];
             memcpy((void*)localFBCI->pAttachments, pCreateInfo->pAttachments, localFBCI->attachmentCount*sizeof(VkImageView));
         }
-        dev_data->frameBufferMap[pFramebuffer->handle] = localFBCI;
+        dev_data->frameBufferMap[*pFramebuffer] = localFBCI;
     }
     return result;
 }
@@ -3475,7 +3471,7 @@
             localRPCI->pDependencies = new VkSubpassDependency[localRPCI->dependencyCount];
             memcpy((void*)localRPCI->pDependencies, pCreateInfo->pDependencies, localRPCI->dependencyCount*sizeof(VkSubpassDependency));
         }
-        dev_data->renderPassMap[pRenderPass->handle] = localRPCI;
+        dev_data->renderPassMap[*pRenderPass] = localRPCI;
     }
     return result;
 }
diff --git a/layers/image.cpp b/layers/image.cpp
index 26f58fd..b741a4c 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -51,7 +51,7 @@
     debug_report_data *report_data;
     std::vector<VkDbgMsgCallback> logging_callback;
     VkPhysicalDevice physicalDevice;
-    unordered_map<uint64_t, IMAGE_STATE> imageMap;
+    unordered_map<VkImage, IMAGE_STATE> imageMap;
 
     layer_data() :
         report_data(nullptr),
@@ -295,7 +295,7 @@
     VkResult result = get_dispatch_table(image_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
 
     if(result == VK_SUCCESS) {
-        device_data->imageMap[pImage->handle] = IMAGE_STATE(pCreateInfo);
+        device_data->imageMap[*pImage] = IMAGE_STATE(pCreateInfo);
     }
     return result;
 }
@@ -303,7 +303,7 @@
 VK_LAYER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
 {
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    device_data->imageMap.erase(image.handle);
+    device_data->imageMap.erase(image);
     get_dispatch_table(image_device_table_map, device)->DestroyImage(device, image);
 }
 
@@ -388,18 +388,18 @@
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
-    auto imageEntry = device_data->imageMap.find(pCreateInfo->image.handle);
+    auto imageEntry = device_data->imageMap.find(pCreateInfo->image);
     if (imageEntry != device_data->imageMap.end()) {
         if (pCreateInfo->subresourceRange.baseMipLevel >= imageEntry->second.mipLevels) {
             std::stringstream ss;
             ss << "vkCreateImageView called with baseMipLevel " << pCreateInfo->subresourceRange.baseMipLevel
-               << " for image " << pCreateInfo->image.handle << " that only has " << imageEntry->second.mipLevels << " mip levels.";
+               << " for image " << pCreateInfo->image << " that only has " << imageEntry->second.mipLevels << " mip levels.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
         }
         if (pCreateInfo->subresourceRange.baseArrayLayer >= imageEntry->second.arraySize) {
             std::stringstream ss;
             ss << "vkCreateImageView called with baseArrayLayer " << pCreateInfo->subresourceRange.baseArrayLayer << " for image "
-               << pCreateInfo->image.handle << " that only has " << imageEntry->second.arraySize << " mip levels.";
+               << pCreateInfo->image << " that only has " << imageEntry->second.arraySize << " mip levels.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
         }
         if (!pCreateInfo->subresourceRange.numLevels) {
@@ -423,20 +423,20 @@
                 std::stringstream ss;
                 ss << "vkCreateImageView: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
             if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != aspectMask) {
                 std::stringstream ss;
                 ss << "vkCreateImageView: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
             if (VK_FALSE == vk_format_is_color(ivciFormat)) {
                 std::stringstream ss;
                 ss << "vkCreateImageView: The image view's format can differ from the parent image's format, but both must be "
                    << "color formats.  ImageFormat is " << string_VkFormat(imageFormat) << " ImageViewFormat is " << string_VkFormat(ivciFormat);
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
             }
             // TODO:  Uncompressed formats are compatible if they occupy they same number of bits per pixel.
             //        Compressed formats are compatible if the only difference between them is the numerical type of
@@ -447,39 +447,39 @@
                 std::stringstream ss;
                 ss << "vkCreateImageView: Combination depth/stencil image formats must have both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
             if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) {
                 std::stringstream ss;
                 ss << "vkCreateImageView: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
         } else  if (vk_format_is_depth_only(imageFormat)) {
             if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) {
                 std::stringstream ss;
                 ss << "vkCreateImageView: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
             if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspectMask) {
                 std::stringstream ss;
                 ss << "vkCreateImageView: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
         } else  if (vk_format_is_stencil_only(imageFormat)) {
             if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) {
                 std::stringstream ss;
                 ss << "vkCreateImageView: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
             if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspectMask) {
                 std::stringstream ss;
                 ss << "vkCreateImageView: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)pCreateInfo->image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
         }
     }
@@ -557,8 +557,8 @@
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    auto srcImageEntry = device_data->imageMap.find(srcImage.handle);
-    auto destImageEntry = device_data->imageMap.find(destImage.handle);
+    auto srcImageEntry = device_data->imageMap.find(srcImage);
+    auto destImageEntry = device_data->imageMap.find(destImage);
 
     // For each region, src and dst number of layers should not be zero
     // For each region, src and dst number of layers must match
@@ -758,8 +758,8 @@
     VkBool32    skipCall    = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
 
-    auto srcImageEntry  = device_data->imageMap.find(srcImage.handle);
-    auto destImageEntry = device_data->imageMap.find(destImage.handle);
+    auto srcImageEntry  = device_data->imageMap.find(srcImage);
+    auto destImageEntry = device_data->imageMap.find(destImage);
 
     if ((srcImageEntry  != device_data->imageMap.end()) &&
         (destImageEntry != device_data->imageMap.end())) {
@@ -877,8 +877,8 @@
 {
     VkBool32 skipCall = VK_FALSE;
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
-    auto srcImageEntry = device_data->imageMap.find(srcImage.handle);
-    auto destImageEntry = device_data->imageMap.find(destImage.handle);
+    auto srcImageEntry = device_data->imageMap.find(srcImage);
+    auto destImageEntry = device_data->imageMap.find(destImage);
 
     // For each region, the number of layers in the image subresource should not be zero
     // For each region, src and dest image aspect must be color only
@@ -945,7 +945,7 @@
     layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     VkFormat    format;
 
-    auto imageEntry = device_data->imageMap.find(image.handle);
+    auto imageEntry = device_data->imageMap.find(image);
 
     // Validate that image aspects match formats
     if (imageEntry != device_data->imageMap.end()) {
@@ -955,7 +955,7 @@
                 std::stringstream ss;
                 ss << "vkGetImageSubresourceLayout: For color formats, the aspect field of VkImageSubresource must be VK_IMAGE_ASPECT_COLOR.";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
         } else if (vk_format_is_depth_or_stencil(format)) {
             if ((pSubresource->aspect != VK_IMAGE_ASPECT_DEPTH_BIT) &&
@@ -963,7 +963,7 @@
                 std::stringstream ss;
                 ss << "vkGetImageSubresourceLayout: For depth/stencil formats, the aspect selects either the depth or stencil image aspect.";
                 skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
-                                   (uint64_t)image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                                   (uint64_t)image, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
             }
         }
     }
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index ffadf24..bd4cb96 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -46,7 +46,7 @@
 
 // WSI Image Objects bypass usual Image Object creation methods.  A special Memory
 // Object value will be used to identify them internally.
-static const VkDeviceMemory MEMTRACKER_SWAP_CHAIN_IMAGE_KEY = static_cast<VkDeviceMemory>(-1);
+static const VkDeviceMemory MEMTRACKER_SWAP_CHAIN_IMAGE_KEY = (VkDeviceMemory)(-1);
 
 struct layer_data {
     debug_report_data *report_data;
@@ -74,11 +74,11 @@
 
 // Maps for tracking key structs related to MemTracker state
 unordered_map<VkCmdBuffer,    MT_CB_INFO>           cbMap;
-unordered_map<uint64_t,       MT_MEM_OBJ_INFO>      memObjMap;
-unordered_map<uint64_t,       MT_FENCE_INFO>        fenceMap;    // Map fence to fence info
+unordered_map<VkDeviceMemory, MT_MEM_OBJ_INFO>      memObjMap;
+unordered_map<VkFence,        MT_FENCE_INFO>        fenceMap;    // Map fence to fence info
 unordered_map<VkQueue,        MT_QUEUE_INFO>        queueMap;
-unordered_map<uint64_t,       MT_SWAP_CHAIN_INFO*>  swapchainMap;
-unordered_map<uint64_t,       MtSemaphoreState>     semaphoreMap;
+unordered_map<VkSwapchainKHR, MT_SWAP_CHAIN_INFO*>  swapchainMap;
+unordered_map<VkSemaphore,    MtSemaphoreState>     semaphoreMap;
 
 // 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> imageMap;
@@ -153,7 +153,7 @@
 {
     MT_SWAP_CHAIN_INFO* pInfo = new MT_SWAP_CHAIN_INFO;
     memcpy(&pInfo->createInfo, pCI, sizeof(VkSwapchainCreateInfoKHR));
-    swapchainMap[swapchain.handle] = pInfo;
+    swapchainMap[swapchain] = pInfo;
 }
 
 // Add new CBInfo for this cb to map container
@@ -240,14 +240,14 @@
     *fenceId = g_currentFenceId++;
 
     // If no fence, create an internal fence to track the submissions
-    if (fence.handle != 0) {
-        fenceMap[fence.handle].fenceId = *fenceId;
-        fenceMap[fence.handle].queue   = queue;
+    if (fence != VK_NULL_HANDLE) {
+        fenceMap[fence].fenceId = *fenceId;
+        fenceMap[fence].queue   = queue;
         // Validate that fence is in UNSIGNALED state
-        VkFenceCreateInfo* pFenceCI = &(fenceMap[fence.handle].createInfo);
+        VkFenceCreateInfo* pFenceCI = &(fenceMap[fence].createInfo);
         if (pFenceCI->flags & VK_FENCE_CREATE_SIGNALED_BIT) {
-            skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, fence.handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
-                           "Fence %#" PRIxLEAST64 " submitted in SIGNALED state.  Fences must be reset before being submitted", fence.handle);
+            skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+                           "Fence %#" PRIxLEAST64 " submitted in SIGNALED state.  Fences must be reset before being submitted", (uint64_t) fence);
         }
     } else {
         // TODO : Do we need to create an internal fence here for tracking purposes?
@@ -261,14 +261,14 @@
 static void delete_fence_info(
     VkFence fence)
 {
-    fenceMap.erase(fence.handle);
+    fenceMap.erase(fence);
 }
 
 // Record information when a fence is known to be signalled
 static void update_fence_tracking(
     VkFence fence)
 {
-    auto fence_item = fenceMap.find(fence.handle);
+    auto fence_item = fenceMap.find(fence);
     if (fence_item != fenceMap.end()) {
         MT_FENCE_INFO *pCurFenceInfo = &(*fence_item).second;
         VkQueue queue = pCurFenceInfo->queue;
@@ -282,7 +282,7 @@
     }
 
     // Update fence state in fenceCreateInfo structure
-    auto pFCI = &(fenceMap[fence.handle].createInfo);
+    auto pFCI = &(fenceMap[fence].createInfo);
     pFCI->flags = static_cast<VkFenceCreateFlags>(pFCI->flags | VK_FENCE_CREATE_SIGNALED_BIT);
 }
 
@@ -337,10 +337,10 @@
                                            char const* func_name, char const* usage_string)
 {
     VkBool32 skipCall = VK_FALSE;
-    MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(image.handle, VK_OBJECT_TYPE_IMAGE);
+    MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info((uint64_t) image, VK_OBJECT_TYPE_IMAGE);
     if (pBindInfo) {
         skipCall = validate_usage_flags(disp_obj, pBindInfo->create_info.image.usage, desired, strict,
-                                      image.handle, VK_OBJECT_TYPE_IMAGE, "image", func_name, usage_string);
+                                      (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "image", func_name, usage_string);
     }
     return skipCall;
 }
@@ -352,10 +352,10 @@
                                             char const* func_name, char const* usage_string)
 {
     VkBool32 skipCall = VK_FALSE;
-    MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info(buffer.handle, VK_OBJECT_TYPE_BUFFER);
+    MT_OBJ_BINDING_INFO* pBindInfo = get_object_binding_info((uint64_t) buffer, VK_OBJECT_TYPE_BUFFER);
     if (pBindInfo) {
         skipCall = validate_usage_flags(disp_obj, pBindInfo->create_info.buffer.usage, desired, strict,
-                                      buffer.handle, VK_OBJECT_TYPE_BUFFER, "buffer", func_name, usage_string);
+                                      (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, "buffer", func_name, usage_string);
     }
     return skipCall;
 }
@@ -363,9 +363,9 @@
 // Return ptr to info in map container containing mem, or NULL if not found
 //  Calls to this function should be wrapped in mutex
 static MT_MEM_OBJ_INFO* get_mem_obj_info(
-    const uint64_t device_mem_handle)
+    VkDeviceMemory mem)
 {
-    auto item = memObjMap.find(device_mem_handle);
+    auto item = memObjMap.find(mem);
     if (item != memObjMap.end()) {
         return &(*item).second;
     } else {
@@ -380,12 +380,12 @@
 {
     assert(object != NULL);
 
-    memcpy(&memObjMap[mem.handle].allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
+    memcpy(&memObjMap[mem].allocInfo, pAllocInfo, sizeof(VkMemoryAllocInfo));
     // TODO:  Update for real hardware, actually process allocation info structures
-    memObjMap[mem.handle].allocInfo.pNext = NULL;
-    memObjMap[mem.handle].object = object;
-    memObjMap[mem.handle].refCount = 0;
-    memObjMap[mem.handle].mem = mem;
+    memObjMap[mem].allocInfo.pNext = NULL;
+    memObjMap[mem].object = object;
+    memObjMap[mem].refCount = 0;
+    memObjMap[mem].mem = mem;
 }
 
 // Find CB Info and add mem reference to list container
@@ -401,11 +401,11 @@
     if (mem != MEMTRACKER_SWAP_CHAIN_IMAGE_KEY) {
 
         // First update CB binding in MemObj mini CB list
-        MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem.handle);
+        MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem);
         if (!pMemInfo) {
             skipCall = log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
                            "In %s, trying to bind mem obj %#" PRIxLEAST64 " to CB %p but no info for that mem obj.\n    "
-                           "Was it correctly allocated? Did it already get freed?", apiName, mem.handle, cb);
+                           "Was it correctly allocated? Did it already get freed?", apiName, (uint64_t) mem, cb);
         } else {
             // Search for cmd buffer object in memory object's binding list
             VkBool32 found  = VK_FALSE;
@@ -427,7 +427,7 @@
             // TODO: keep track of all destroyed CBs so we know if this is a stale or simply invalid object
             if (!pCBInfo) {
                 skipCall = log_msg(mdd(cb), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
-                               "Trying to bind mem obj %#" PRIxLEAST64 " to CB %p but no info for that CB. Was CB incorrectly destroyed?", mem.handle, cb);
+                               "Trying to bind mem obj %#" PRIxLEAST64 " to CB %p but no info for that CB. Was CB incorrectly destroyed?", (uint64_t) mem, cb);
             } else {
                 // Search for memory object in cmd buffer's reference list
                 VkBool32 found  = VK_FALSE;
@@ -462,7 +462,7 @@
         if (pCBInfo->pMemObjList.size() > 0) {
             list<VkDeviceMemory> mem_obj_list = pCBInfo->pMemObjList;
             for (list<VkDeviceMemory>::iterator it=mem_obj_list.begin(); it!=mem_obj_list.end(); ++it) {
-                MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info((*it).handle);
+                MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(*it);
                 pInfo->pCmdBufferBindings.remove(cb);
                 pInfo->refCount--;
             }
@@ -493,16 +493,16 @@
     size_t objRefCount    = pMemObjInfo->pObjBindings.size();
 
     if ((pMemObjInfo->pCmdBufferBindings.size() + pMemObjInfo->pObjBindings.size()) != 0) {
-        skipCall = log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pMemObjInfo->mem.handle, 0, MEMTRACK_FREED_MEM_REF, "MEM",
+        skipCall = log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pMemObjInfo->mem, 0, MEMTRACK_FREED_MEM_REF, "MEM",
                        "Attempting to free memory object %#" PRIxLEAST64 " which still contains %lu references",
-                       pMemObjInfo->mem.handle, (cmdBufRefCount + objRefCount));
+                       (uint64_t) pMemObjInfo->mem, (cmdBufRefCount + objRefCount));
     }
 
     if (cmdBufRefCount > 0 && pMemObjInfo->pCmdBufferBindings.size() > 0) {
         for (list<VkCmdBuffer>::const_iterator it = pMemObjInfo->pCmdBufferBindings.begin(); it != pMemObjInfo->pCmdBufferBindings.end(); ++it) {
             // TODO : cmdBuffer should be source Obj here
             log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)(*it), 0, MEMTRACK_FREED_MEM_REF, "MEM",
-                    "Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), pMemObjInfo->mem.handle);
+                    "Command Buffer %p still has a reference to mem obj %#" PRIxLEAST64, (*it), (uint64_t) pMemObjInfo->mem);
         }
         // Clear the list of hanging references
         pMemObjInfo->pCmdBufferBindings.clear();
@@ -511,7 +511,7 @@
     if (objRefCount > 0 && pMemObjInfo->pObjBindings.size() > 0) {
         for (auto it = pMemObjInfo->pObjBindings.begin(); it != pMemObjInfo->pObjBindings.end(); ++it) {
             log_msg(mdd(pMemObjInfo->object), VK_DBG_REPORT_INFO_BIT, it->type, it->handle, 0, MEMTRACK_FREED_MEM_REF, "MEM",
-                    "VK Object %#" PRIxLEAST64 " still has a reference to mem obj %#" PRIxLEAST64, it->handle, pMemObjInfo->mem.handle);
+                    "VK Object %#" PRIxLEAST64 " still has a reference to mem obj %#" PRIxLEAST64, it->handle, (uint64_t) pMemObjInfo->mem);
         }
         // Clear the list of hanging references
         pMemObjInfo->pObjBindings.clear();
@@ -521,15 +521,15 @@
 
 static VkBool32 deleteMemObjInfo(
     void* object,
-    const uint64_t device_mem_handle)
+    VkDeviceMemory mem)
 {
     VkBool32 skipCall = VK_FALSE;
-    auto item = memObjMap.find(device_mem_handle);
+    auto item = memObjMap.find(mem);
     if (item != memObjMap.end()) {
         memObjMap.erase(item);
     } else {
-        skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, device_mem_handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
-                       "Request to delete memory object %#" PRIxLEAST64 " not present in memory Object Map", device_mem_handle);
+        skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+                       "Request to delete memory object %#" PRIxLEAST64 " not present in memory Object Map", (uint64_t) mem);
     }
     return skipCall;
 }
@@ -552,7 +552,7 @@
         if (pCBInfo->fenceId > pQueueInfo->lastRetiredId) {
             log_msg(mdd(cb), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, (uint64_t)cb, 0,
                 MEMTRACK_NONE, "MEM", "fence %#" PRIxLEAST64 " for CB %p has not been checked for completion",
-                pCBInfo->lastSubmittedFence.handle, cb);
+                (uint64_t) pCBInfo->lastSubmittedFence, cb);
             *complete = VK_FALSE;
         }
     }
@@ -566,16 +566,16 @@
 {
     VkBool32 skipCall = VK_FALSE;
     // Parse global list to find info w/ mem
-    MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem.handle);
+    MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
     if (!pInfo) {
-        skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+        skipCall = log_msg(mdd(object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
                        "Couldn't find mem info object for %#" PRIxLEAST64 "\n    Was %#" PRIxLEAST64 " never allocated or previously freed?",
-                       mem.handle, mem.handle);
+                       (uint64_t) mem, (uint64_t) mem);
     } else {
         if (pInfo->allocInfo.allocationSize == 0 && !internal) {
-            skipCall = log_msg(mdd(pInfo->object), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+            skipCall = log_msg(mdd(pInfo->object), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
                             "Attempting to free memory associated with a Persistent Image, %#" PRIxLEAST64 ", "
-                            "this should not be explicitly freed\n", mem.handle);
+                            "this should not be explicitly freed\n", (uint64_t) mem);
         } else {
             // Clear any CB bindings for completed CBs
             //   TODO : Is there a better place to do this?
@@ -601,7 +601,7 @@
                 skipCall |= reportMemReferencesAndCleanUp(pInfo);
             }
             // Delete mem obj info
-            skipCall |= deleteMemObjInfo(object, mem.handle);
+            skipCall |= deleteMemObjInfo(object, mem);
         }
     }
     return skipCall;
@@ -635,7 +635,7 @@
     VkBool32 skipCall = VK_FALSE;
     MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(handle, type);
     if (pObjBindInfo) {
-        MT_MEM_OBJ_INFO* pMemObjInfo = get_mem_obj_info(pObjBindInfo->mem.handle);
+        MT_MEM_OBJ_INFO* pMemObjInfo = get_mem_obj_info(pObjBindInfo->mem);
         if (!pMemObjInfo) {
             skipCall = log_msg(mdd(dispObj), VK_DBG_REPORT_WARN_BIT, type, handle, 0, MEMTRACK_MEM_OBJ_CLEAR_EMPTY_BINDINGS, "MEM",
                            "Attempting to clear mem binding on %s obj %#" PRIxLEAST64 " but it has no binding.",
@@ -649,7 +649,7 @@
                     pMemObjInfo->refCount--;
                     pMemObjInfo->pObjBindings.erase(it);
                     // TODO : Make sure this is a reasonable way to reset mem binding
-                    pObjBindInfo->mem.handle = 0;
+                    pObjBindInfo->mem = VK_NULL_HANDLE;
                     clearSucceeded = VK_TRUE;
                     break;
                 }
@@ -657,7 +657,7 @@
             if (VK_FALSE == clearSucceeded ) {
                 skipCall |= log_msg(mdd(dispObj), VK_DBG_REPORT_ERROR_BIT, type, handle, 0, MEMTRACK_INVALID_OBJECT, "MEM",
                                 "While trying to clear mem binding for %s obj %#" PRIxLEAST64 ", unable to find that object referenced by mem obj %#" PRIxLEAST64,
-                                 object_type_to_string(type), handle, pMemObjInfo->mem.handle);
+                                 object_type_to_string(type), handle, (uint64_t) pMemObjInfo->mem);
             }
         }
     }
@@ -691,18 +691,18 @@
                             object_type_to_string(type), apiName, handle);
         } else {
             // non-null case so should have real mem obj
-            MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem.handle);
+            MT_MEM_OBJ_INFO* pMemInfo = get_mem_obj_info(mem);
             if (!pMemInfo) {
-                skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle,
+                skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem,
                                 0, MEMTRACK_INVALID_MEM_OBJ, "MEM", "In %s, while trying to bind mem for %s obj %#" PRIxLEAST64 ", couldn't find info for mem obj %#" PRIxLEAST64,
-                                object_type_to_string(type), apiName, handle, mem.handle);
+                                object_type_to_string(type), apiName, handle, (uint64_t) mem);
             } else {
                 // TODO : Need to track mem binding for obj and report conflict here
-                MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem.handle);
+                MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem);
                 if (pPrevBinding != NULL) {
-                    skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_REBIND_OBJECT, "MEM",
+                    skipCall |= log_msg(mdd(dispatch_object), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_REBIND_OBJECT, "MEM",
                             "In %s, attempting to bind memory (%#" PRIxLEAST64 ") to object (%#" PRIxLEAST64 ") which has already been bound to mem object %#" PRIxLEAST64,
-                            apiName, mem.handle, handle, pPrevBinding->mem.handle);
+                            apiName, (uint64_t) mem, handle, (uint64_t) pPrevBinding->mem);
                 }
                 else {
                     MT_OBJ_HANDLE_TYPE oht;
@@ -751,10 +751,10 @@
                             "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
-        MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem.handle);
+        MT_MEM_OBJ_INFO* pInfo = get_mem_obj_info(mem);
         if (!pInfo) {
-            skipCall |= log_msg(mdd(dispObject), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
-                            "In %s, While trying to bind mem for obj %#" PRIxLEAST64 ", couldn't find info for mem obj %#" PRIxLEAST64, apiName, handle, mem.handle);
+            skipCall |= log_msg(mdd(dispObject), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_MEM_OBJ, "MEM",
+                            "In %s, While trying to bind mem for obj %#" PRIxLEAST64 ", couldn't find info for mem obj %#" PRIxLEAST64, apiName, handle, (uint64_t) mem);
         } else {
             // Search for object in memory object's binding list
             VkBool32 found  = VK_FALSE;
@@ -775,7 +775,7 @@
                 pInfo->refCount++;
             }
             // Need to set mem binding for this object
-            MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem.handle);
+            MT_MEM_OBJ_INFO* pPrevBinding = get_mem_obj_info(pObjBindInfo->mem);
             pObjBindInfo->mem = mem;
         }
     }
@@ -800,7 +800,7 @@
     void* dispObj, const uint64_t handle, const VkDbgObjectType type, VkDeviceMemory *mem)
 {
     VkBool32 skipCall = VK_FALSE;
-    mem->handle = 0;
+    *mem = VK_NULL_HANDLE;
     MT_OBJ_BINDING_INFO* pObjBindInfo = get_object_binding_info(handle, type);
     if (pObjBindInfo) {
         if (pObjBindInfo->mem) {
@@ -843,7 +843,7 @@
         log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
             "    ===MemObjInfo at %p===", (void*)pInfo);
         log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
-                "    Mem object: %#" PRIxLEAST64, (void*)pInfo->mem.handle);
+                "    Mem object: %#" PRIxLEAST64, (void*)pInfo->mem);
         log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
                 "    Ref Count: %u", pInfo->refCount);
         if (0 != pInfo->allocInfo.allocationSize) {
@@ -900,7 +900,7 @@
         log_msg(mdd(dispObj), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, 0, 0, MEMTRACK_NONE, "MEM",
                 "    CB Info (%p) has CB %p, fenceId %" PRIx64", and fence %#" PRIxLEAST64,
                 (void*)pCBInfo, (void*)pCBInfo->cmdBuffer, pCBInfo->fenceId,
-                pCBInfo->lastSubmittedFence.handle);
+                (uint64_t) pCBInfo->lastSubmittedFence);
 
         if (pCBInfo->pMemObjList.size() <= 0)
             continue;
@@ -1048,7 +1048,7 @@
         for (auto ii=memObjMap.begin(); ii!=memObjMap.end(); ++ii) {
             pInfo = &(*ii).second;
             if (pInfo->allocInfo.allocationSize != 0) {
-                skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, pInfo->mem.handle, 0, MEMTRACK_MEMORY_LEAK, "MEM",
+                skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) pInfo->mem, 0, MEMTRACK_MEMORY_LEAK, "MEM",
                                  "Mem Object %p has not been freed. You should clean up this memory by calling "
                                  "vkFreeMemory(%p) prior to vkDestroyDevice().", pInfo->mem, pInfo->mem);
             }
@@ -1167,25 +1167,25 @@
         for (uint32_t i = 0; i < submit->waitSemCount; i++) {
             VkSemaphore sem = submit->pWaitSemaphores[i];
 
-            if (semaphoreMap.find(sem.handle) != semaphoreMap.end()) {
-                if (semaphoreMap[sem.handle] != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) {
-                    skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, sem.handle,
+            if (semaphoreMap.find(sem) != semaphoreMap.end()) {
+                if (semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_SIGNALLED) {
+                    skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem,
                             0, MEMTRACK_NONE, "SEMAPHORE",
                             "vkQueueSubmit: Semaphore must be in signaled state before passing to pWaitSemaphores");
                 }
-                semaphoreMap[sem.handle] = MEMTRACK_SEMAPHORE_STATE_WAIT;
+                semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_WAIT;
             }
         }
         for (uint32_t i = 0; i < submit->signalSemCount; i++) {
             VkSemaphore sem = submit->pWaitSemaphores[i];
 
-            if (semaphoreMap.find(sem.handle) != semaphoreMap.end()) {
-                if (semaphoreMap[sem.handle] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
-                    skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, sem.handle,
+            if (semaphoreMap.find(sem) != semaphoreMap.end()) {
+                if (semaphoreMap[sem] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
+                    skipCall = log_msg(mdd(queue), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) sem,
                             0, MEMTRACK_NONE, "SEMAPHORE",
                             "vkQueueSubmit: Semaphore must not be currently signaled or in a wait state");
                 }
-                semaphoreMap[sem.handle] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
+                semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
             }
         }
     }
@@ -1202,8 +1202,8 @@
         for (uint32_t i = 0; i < submit->waitSemCount; i++) {
             VkSemaphore sem = submit->pWaitSemaphores[i];
 
-            if (semaphoreMap.find(sem.handle) != semaphoreMap.end()) {
-                semaphoreMap[sem.handle] = MEMTRACK_SEMAPHORE_STATE_UNSET;
+            if (semaphoreMap.find(sem) != semaphoreMap.end()) {
+                semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_UNSET;
             }
         }
     }
@@ -1254,11 +1254,11 @@
     VkBool32 skipCall = VK_FALSE;
     VkResult result   = VK_ERROR_VALIDATION_FAILED;
     loader_platform_thread_lock_mutex(&globalLock);
-    MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(mem.handle);
+    MT_MEM_OBJ_INFO *pMemObj = get_mem_obj_info(mem);
     if ((memProps.memoryTypes[pMemObj->allocInfo.memoryTypeIndex].propertyFlags &
          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) == 0) {
-        skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem.handle, 0, MEMTRACK_INVALID_STATE, "MEM",
-                       "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %#" PRIxLEAST64, mem.handle);
+        skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t) mem, 0, MEMTRACK_INVALID_STATE, "MEM",
+                       "Mapping Memory without VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT set: mem obj %#" PRIxLEAST64, (uint64_t) mem);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1280,7 +1280,7 @@
 {
     loader_platform_thread_lock_mutex(&globalLock);
     delete_fence_info(fence);
-    auto item = fenceMap.find(fence.handle);
+    auto item = fenceMap.find(fence);
     if (item != fenceMap.end()) {
         fenceMap.erase(item);
     }
@@ -1292,9 +1292,9 @@
 {
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    auto item = bufferMap.find(buffer.handle);
+    auto item = bufferMap.find((uint64_t) buffer);
     if (item != bufferMap.end()) {
-        skipCall = clear_object_binding(device, buffer.handle, VK_OBJECT_TYPE_BUFFER);
+        skipCall = clear_object_binding(device, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER);
         bufferMap.erase(item);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
@@ -1307,9 +1307,9 @@
 {
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    auto item = imageMap.find(image.handle);
+    auto item = imageMap.find((uint64_t) image);
     if (item != imageMap.end()) {
-        skipCall = clear_object_binding(device, image.handle, VK_OBJECT_TYPE_IMAGE);
+        skipCall = clear_object_binding(device, (uint64_t) image, VK_OBJECT_TYPE_IMAGE);
         imageMap.erase(item);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
@@ -1327,8 +1327,8 @@
     VkResult result = VK_ERROR_VALIDATION_FAILED;
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    VkBool32 skipCall = set_mem_binding(device, mem, buffer.handle, VK_OBJECT_TYPE_BUFFER, "vkBindBufferMemory");
-    add_object_binding_info(buffer.handle, VK_OBJECT_TYPE_BUFFER, mem);
+    VkBool32 skipCall = set_mem_binding(device, mem, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, "vkBindBufferMemory");
+    add_object_binding_info((uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, mem);
     print_mem_list(device);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1346,8 +1346,8 @@
     VkResult result = VK_ERROR_VALIDATION_FAILED;
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    VkBool32 skipCall = set_mem_binding(device, mem, image.handle, VK_OBJECT_TYPE_IMAGE, "vkBindImageMemory");
-    add_object_binding_info(image.handle, VK_OBJECT_TYPE_IMAGE, mem);
+    VkBool32 skipCall = set_mem_binding(device, mem, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "vkBindImageMemory");
+    add_object_binding_info((uint64_t) image, VK_OBJECT_TYPE_IMAGE, mem);
     print_mem_list(device);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1385,7 +1385,7 @@
     VkResult result = VK_ERROR_VALIDATION_FAILED;
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, image.handle, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageOpaqeMemory");
+    VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageOpaqeMemory");
     print_mem_list(queue);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1403,7 +1403,7 @@
     VkResult result = VK_ERROR_VALIDATION_FAILED;
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, image.handle, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageMemory");
+    VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, "vkQueueBindSparseImageMemory");
     print_mem_list(queue);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1422,7 +1422,7 @@
     VkResult result = VK_ERROR_VALIDATION_FAILED;
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, buffer.handle, VK_OBJECT_TYPE_BUFFER, "VkQueueBindSparseBufferMemory");
+    VkBool32 skipCall = set_sparse_mem_binding(queue, pBindInfo->mem, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, "VkQueueBindSparseBufferMemory");
     print_mem_list(queue);
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1440,7 +1440,7 @@
     VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateFence(device, pCreateInfo, pFence);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        MT_FENCE_INFO* pFI = &fenceMap[pFence->handle];
+        MT_FENCE_INFO* pFI = &fenceMap[*pFence];
         memset(pFI, 0, sizeof(MT_FENCE_INFO));
         memcpy(&(pFI->createInfo), pCreateInfo, sizeof(VkFenceCreateInfo));
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -1459,12 +1459,12 @@
     loader_platform_thread_lock_mutex(&globalLock);
     // Reset fence state in fenceCreateInfo structure
     for (uint32_t i = 0; i < fenceCount; i++) {
-        auto fence_item = fenceMap.find(pFences[i].handle);
+        auto fence_item = fenceMap.find(pFences[i]);
         if (fence_item != fenceMap.end()) {
             // Validate fences in SIGNALED state
             if (!(fence_item->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT)) {
-                skipCall = log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, pFences[i].handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
-                        "Fence %#" PRIxLEAST64 " submitted to VkResetFences in UNSIGNALED STATE", pFences[i].handle);
+                skipCall = log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) pFences[i], 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+                        "Fence %#" PRIxLEAST64 " submitted to VkResetFences in UNSIGNALED STATE", (uint64_t) pFences[i]);
             }
             else {
                 fence_item->second.createInfo.flags =
@@ -1482,15 +1482,15 @@
 static inline VkBool32 verifyFenceStatus(VkDevice device, VkFence fence, const char* apiCall)
 {
     VkBool32 skipCall = VK_FALSE;
-    auto pFenceInfo = fenceMap.find(fence.handle);
+    auto pFenceInfo = fenceMap.find(fence);
     if (pFenceInfo != fenceMap.end()) {
         if (pFenceInfo->second.createInfo.flags & VK_FENCE_CREATE_SIGNALED_BIT) {
-            skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, fence.handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
-                "%s specified fence %#" PRIxLEAST64 " already in SIGNALED state.", apiCall, fence.handle);
+            skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+                "%s specified fence %#" PRIxLEAST64 " already in SIGNALED state.", apiCall, (uint64_t) fence);
         }
         if (!pFenceInfo->second.queue) { // Checking status of unsubmitted fence
-            skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, fence.handle, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
-                "%s called for fence %#" PRIxLEAST64 " which has not been submitted on a Queue.", apiCall, fence.handle);
+            skipCall |= log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_FENCE, (uint64_t) fence, 0, MEMTRACK_INVALID_FENCE_STATE, "MEM",
+                "%s called for fence %#" PRIxLEAST64 " which has not been submitted on a Queue.", apiCall, (uint64_t) fence);
         }
     }
     return skipCall;
@@ -1572,7 +1572,7 @@
     VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        add_object_create_info(pBuffer->handle, VK_OBJECT_TYPE_BUFFER, pCreateInfo);
+        add_object_create_info((uint64_t) *pBuffer, VK_OBJECT_TYPE_BUFFER, pCreateInfo);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -1586,7 +1586,7 @@
     VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateImage(device, pCreateInfo, pImage);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        add_object_create_info(pImage->handle, VK_OBJECT_TYPE_IMAGE, pCreateInfo);
+        add_object_create_info((uint64_t) *pImage, VK_OBJECT_TYPE_IMAGE, pCreateInfo);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return result;
@@ -1931,7 +1931,7 @@
 {
     VkDeviceMemory mem;
     loader_platform_thread_lock_mutex(&globalLock);
-    VkBool32 skipCall  = get_mem_binding_from_object(cmdBuffer, buffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    VkBool32 skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall          |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdDrawIndirect");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1948,7 +1948,7 @@
 {
     VkDeviceMemory mem;
     loader_platform_thread_lock_mutex(&globalLock);
-    VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, buffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall         |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdDrawIndexedIndirect");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1963,7 +1963,7 @@
 {
     VkDeviceMemory mem;
     loader_platform_thread_lock_mutex(&globalLock);
-    VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, buffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    VkBool32 skipCall = get_mem_binding_from_object(cmdBuffer, (uint64_t) buffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall         |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdDispatchIndirect");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -1981,9 +1981,9 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(cmdBuffer, srcBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBuffer");
-    skipCall |= get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBuffer");
     // Validate that SRC & DST buffers have correct usage flags set
     skipCall |= validate_buffer_usage_flags(cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBuffer()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
@@ -2007,7 +2007,7 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall |= get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyQueryPoolResults");
     // Validate that DST buffer has correct usage flags set
     skipCall |= validate_buffer_usage_flags(cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyQueryPoolResults()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2030,9 +2030,9 @@
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     // Validate that src & dst images have correct usage flags set
-    skipCall  = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImage");
-    skipCall |= get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImage");
     skipCall |= validate_image_usage_flags(cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
     skipCall |= validate_image_usage_flags(cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdCopyImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2057,9 +2057,9 @@
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     // Validate that src & dst images have correct usage flags set
-    skipCall  = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdBlitImage");
-    skipCall |= get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdBlitImage");
     skipCall |= validate_image_usage_flags(cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
     skipCall |= validate_image_usage_flags(cmdBuffer, destImage, VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdBlitImage()", "VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2081,9 +2081,9 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBufferToImage");
-    skipCall |= get_mem_binding_from_object(cmdBuffer, srcBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) srcBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyBufferToImage");
     // Validate that src buff & dst image have correct usage flags set
     skipCall |= validate_buffer_usage_flags(cmdBuffer, srcBuffer, VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyBufferToImage()", "VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT");
@@ -2106,9 +2106,9 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImageToBuffer");
-    skipCall |= get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdCopyImageToBuffer");
     // Validate that dst buff & src image have correct usage flags set
     skipCall |= validate_image_usage_flags(cmdBuffer, srcImage, VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT, true, "vkCmdCopyImageToBuffer()", "VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT");
@@ -2130,7 +2130,7 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdUpdateBuffer");
     // Validate that dst buff has correct usage flags set
     skipCall |= validate_buffer_usage_flags(cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdUpdateBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2150,7 +2150,7 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(cmdBuffer, destBuffer.handle, VK_OBJECT_TYPE_BUFFER, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) destBuffer, VK_OBJECT_TYPE_BUFFER, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdFillBuffer");
     // Validate that dst buff has correct usage flags set
     skipCall |= validate_buffer_usage_flags(cmdBuffer, destBuffer, VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT, true, "vkCmdFillBuffer()", "VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT");
@@ -2172,7 +2172,7 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(cmdBuffer, image.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdClearColorImage");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -2192,7 +2192,7 @@
     VkDeviceMemory mem;
     VkBool32       skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
-    skipCall  = get_mem_binding_from_object(cmdBuffer, image.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) image, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdClearDepthStencilImage");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -2213,9 +2213,9 @@
     VkBool32 skipCall = VK_FALSE;
     loader_platform_thread_lock_mutex(&globalLock);
     VkDeviceMemory mem;
-    skipCall  = get_mem_binding_from_object(cmdBuffer, srcImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall  = get_mem_binding_from_object(cmdBuffer, (uint64_t) srcImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdResolveImage");
-    skipCall |= get_mem_binding_from_object(cmdBuffer, destImage.handle, VK_OBJECT_TYPE_IMAGE, &mem);
+    skipCall |= get_mem_binding_from_object(cmdBuffer, (uint64_t) destImage, VK_OBJECT_TYPE_IMAGE, &mem);
     skipCall |= update_cmd_buf_and_mem_references(cmdBuffer, mem, "vkCmdResolveImage");
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -2303,19 +2303,19 @@
     VkBool32 skipCall = VK_FALSE;
     VkResult result   = VK_ERROR_VALIDATION_FAILED;
     loader_platform_thread_lock_mutex(&globalLock);
-    if (swapchainMap.find(swapchain.handle) != swapchainMap.end()) {
-        MT_SWAP_CHAIN_INFO* pInfo = swapchainMap[swapchain.handle];
+    if (swapchainMap.find(swapchain) != swapchainMap.end()) {
+        MT_SWAP_CHAIN_INFO* pInfo = swapchainMap[swapchain];
 
         if (pInfo->images.size() > 0) {
             for (auto it = pInfo->images.begin(); it != pInfo->images.end(); it++) {
-                skipCall = clear_object_binding(device, it->handle, VK_OBJECT_TYPE_SWAPCHAIN_KHR);
-                auto image_item = imageMap.find(it->handle);
+                skipCall = clear_object_binding(device, (uint64_t) *it, VK_OBJECT_TYPE_SWAPCHAIN_KHR);
+                auto image_item = imageMap.find((uint64_t) *it);
                 if (image_item != imageMap.end())
                     imageMap.erase(image_item);
             }
         }
         delete pInfo;
-        swapchainMap.erase(swapchain.handle);
+        swapchainMap.erase(swapchain);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -2334,7 +2334,7 @@
 
     if (result == VK_SUCCESS && pSwapchainImages != NULL) {
         const size_t count = *pCount;
-        MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain.handle];
+        MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain];
 
         if (pInfo->images.empty()) {
             pInfo->images.resize(count);
@@ -2344,17 +2344,17 @@
                 for (std::vector<VkImage>::const_iterator it = pInfo->images.begin();
                      it != pInfo->images.end(); it++) {
                     // Add image object binding, then insert the new Mem Object and then bind it to created image
-                    add_object_create_info(it->handle, VK_OBJECT_TYPE_SWAPCHAIN_KHR, &pInfo->createInfo);
+                    add_object_create_info((uint64_t) *it, VK_OBJECT_TYPE_SWAPCHAIN_KHR, &pInfo->createInfo);
                 }
             }
         } else {
             const size_t count = *pCount;
-            MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain.handle];
+            MT_SWAP_CHAIN_INFO *pInfo = swapchainMap[swapchain];
             const bool mismatch = (pInfo->images.size() != count ||
                     memcmp(&pInfo->images[0], pSwapchainImages, sizeof(pInfo->images[0]) * count));
 
             if (mismatch) {
-                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAPCHAIN_KHR, swapchain.handle, 0, MEMTRACK_NONE, "SWAP_CHAIN",
+                log_msg(mdd(device), VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_SWAPCHAIN_KHR, (uint64_t) swapchain, 0, MEMTRACK_NONE, "SWAP_CHAIN",
                         "vkGetSwapchainInfoKHR(%p, VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_KHR) returned mismatching data", swapchain);
             }
         }
@@ -2373,13 +2373,13 @@
     VkBool32 skipCall = VK_FALSE;
 
     loader_platform_thread_lock_mutex(&globalLock);
-    if (semaphoreMap.find(semaphore.handle) != semaphoreMap.end()) {
-        if (semaphoreMap[semaphore.handle] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
-            skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, semaphore.handle,
+    if (semaphoreMap.find(semaphore) != semaphoreMap.end()) {
+        if (semaphoreMap[semaphore] != MEMTRACK_SEMAPHORE_STATE_UNSET) {
+            skipCall = log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_SEMAPHORE, (uint64_t) semaphore,
                                0, MEMTRACK_NONE, "SEMAPHORE",
                                "vkAcquireNextImageKHR: Semaphore must not be currently signaled or in a wait state");
         }
-        semaphoreMap[semaphore.handle] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
+        semaphoreMap[semaphore] = MEMTRACK_SEMAPHORE_STATE_SIGNALLED;
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     if (VK_FALSE == skipCall) {
@@ -2396,8 +2396,8 @@
 {
     VkResult result = get_dispatch_table(mem_tracker_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pSemaphore);
     loader_platform_thread_lock_mutex(&globalLock);
-    if (pSemaphore->handle != 0) {
-        semaphoreMap[pSemaphore->handle] = MEMTRACK_SEMAPHORE_STATE_UNSET;
+    if (*pSemaphore != VK_NULL_HANDLE) {
+        semaphoreMap[*pSemaphore] = MEMTRACK_SEMAPHORE_STATE_UNSET;
     }
     loader_platform_thread_unlock_mutex(&globalLock);
     return result;
@@ -2408,7 +2408,7 @@
     VkSemaphore semaphore)
 {
     loader_platform_thread_lock_mutex(&globalLock);
-    auto item = semaphoreMap.find(semaphore.handle);
+    auto item = semaphoreMap.find(semaphore);
     if (item != semaphoreMap.end()) {
         semaphoreMap.erase(item);
     }
diff --git a/layers/object_track.h b/layers/object_track.h
index c2f0e67..ea75743 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -451,20 +451,20 @@
 
 static VkBool32 validate_object(VkQueue dispatchable_object, VkImage object)
 {
-    if ((VkImageMap.find((void*)object.handle)        == VkImageMap.end()) &&
-        (swapchainImageMap.find((void*)object.handle) == swapchainImageMap.end())) {
-        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid VkImage Object %p", object.handle);
+    if ((VkImageMap.find((void*)object)        == VkImageMap.end()) &&
+        (swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {
+        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid VkImage Object %p", object);
     }
     return VK_FALSE;
 }
 
 static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkImage object)
 {
-    if ((VkImageMap.find((void*)object.handle)        == VkImageMap.end()) &&
-        (swapchainImageMap.find((void*)object.handle) == swapchainImageMap.end())) {
-        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid VkImage Object %p", object.handle);
+    if ((VkImageMap.find((void*)object)        == VkImageMap.end()) &&
+        (swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {
+        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid VkImage Object %p", object);
     }
     return VK_FALSE;
 }
@@ -480,18 +480,18 @@
 
 static VkBool32 validate_object(VkCmdBuffer dispatchable_object, VkDescriptorSet object)
 {
-    if (VkDescriptorSetMap.find((void*)object.handle) == VkDescriptorSetMap.end()) {
-        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid VkDescriptorSet Object %p", object.handle);
+    if (VkDescriptorSetMap.find((void*)object) == VkDescriptorSetMap.end()) {
+        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid VkDescriptorSet Object %p", object);
     }
     return VK_FALSE;
 }
 
 static VkBool32 validate_object(VkQueue dispatchable_object, VkBuffer object)
 {
-    if (VkBufferMap.find((void*)object.handle) != VkBufferMap.end()) {
-        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid VkBuffer Object %p", object.handle);
+    if (VkBufferMap.find((void*)object) != VkBufferMap.end()) {
+        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid VkBuffer Object %p", object);
     }
     return VK_FALSE;
 }
@@ -500,15 +500,15 @@
 {
     VkBool32 skipCall = VK_FALSE;
     if (object != VK_NULL_HANDLE) {
-        if (VkFenceMap.find((void*)object.handle) != VkFenceMap.end()) {
-            OBJTRACK_NODE* pNode = VkFenceMap[(void*)object.handle];
+        if (VkFenceMap.find((void*)object) != VkFenceMap.end()) {
+            OBJTRACK_NODE* pNode = VkFenceMap[(void*)object];
             pNode->status |= status_flag;
         }
         else {
             // If we do not find it print an error
-            skipCall |= log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+            skipCall |= log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK",
                 "Unable to set status for non-existent object 0x%" PRIxLEAST64 " of %s type",
-                object.handle, string_VkDbgObjectType(objType));
+                (uint64_t) object, string_VkDbgObjectType(objType));
         }
     }
     return skipCall;
@@ -516,9 +516,9 @@
 
 static VkBool32 validate_object(VkQueue dispatchable_object, VkSemaphore object)
 {
-    if (VkSemaphoreMap.find((void*)object.handle) == VkSemaphoreMap.end()) {
-        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
-            "Invalid VkSemaphore Object %p", object.handle);
+    if (VkSemaphoreMap.find((void*)object) == VkSemaphoreMap.end()) {
+        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",
+            "Invalid VkSemaphore Object %p", object);
     }
     return VK_FALSE;
 }
@@ -565,15 +565,15 @@
 }
 static void create_obj(VkDevice dispatchable_object, VkSwapchainKHR vkObj, VkDbgObjectType objType)
 {
-    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
         "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, string_VkDbgObjectType(objType),
-        vkObj.handle);
+        (uint64_t) vkObj);
 
     OBJTRACK_NODE* pNewObjNode = new OBJTRACK_NODE;
     pNewObjNode->objType = objType;
     pNewObjNode->status  = OBJSTATUS_NONE;
-    pNewObjNode->vkObj  = vkObj.handle;
-    VkSwapchainKHRMap[(void*) vkObj.handle] = pNewObjNode;
+    pNewObjNode->vkObj  = (uint64_t) vkObj;
+    VkSwapchainKHRMap[(void*) vkObj] = pNewObjNode;
     uint32_t objIndex = objTypeToIndex(objType);
     numObjs[objIndex]++;
     numTotalObjs++;
@@ -595,37 +595,37 @@
 }
 static void create_swapchain_image_obj(VkDevice dispatchable_object, VkImage vkObj, VkSwapchainKHR swapchain)
 {
-    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_IMAGE, vkObj.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_IMAGE, (uint64_t) vkObj, 0, OBJTRACK_NONE, "OBJTRACK",
         "OBJ[%llu] : CREATE %s object 0x%" PRIxLEAST64 , object_track_index++, "SwapchainImage",
-        vkObj.handle);
+        (uint64_t) vkObj);
 
     OBJTRACK_NODE* pNewObjNode             = new OBJTRACK_NODE;
     pNewObjNode->objType                   = VK_OBJECT_TYPE_IMAGE;
     pNewObjNode->status                    = OBJSTATUS_NONE;
-    pNewObjNode->vkObj                     = vkObj.handle;
-    pNewObjNode->parentObj                 = swapchain.handle;
-    swapchainImageMap[(void*)vkObj.handle] = pNewObjNode;
+    pNewObjNode->vkObj                     = (uint64_t) vkObj;
+    pNewObjNode->parentObj                 = (uint64_t) swapchain;
+    swapchainImageMap[(void*)vkObj] = pNewObjNode;
 }
 
 static void destroy_obj(VkDevice dispatchable_object, VkSwapchainKHR object)
 {
-    if (VkSwapchainKHRMap.find((void*) object.handle) != VkSwapchainKHRMap.end()) {
-        OBJTRACK_NODE* pNode = VkSwapchainKHRMap[(void*) object.handle];
+    if (VkSwapchainKHRMap.find((void*) object) != VkSwapchainKHRMap.end()) {
+        OBJTRACK_NODE* pNode = VkSwapchainKHRMap[(void*) 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, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK",
            "OBJ_STAT Destroy %s obj 0x%" PRIxLEAST64 " (%lu total objs remain & %lu %s objs).",
-            string_VkDbgObjectType(pNode->objType), object.handle, numTotalObjs, numObjs[objIndex],
+            string_VkDbgObjectType(pNode->objType), (uint64_t) object, numTotalObjs, numObjs[objIndex],
             string_VkDbgObjectType(pNode->objType));
         delete pNode;
-        VkSwapchainKHRMap.erase((void*) object.handle);
+        VkSwapchainKHRMap.erase((void*) object);
     } else {
-        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_NONE, "OBJTRACK",
+        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_NONE, "OBJTRACK",
             "Unable to remove obj 0x%" PRIxLEAST64 ". Was it created? Has it already been destroyed?",
-           object.handle);
+           (uint64_t) object);
     }
 }
 //
@@ -856,7 +856,7 @@
     unordered_map<const void*, OBJTRACK_NODE*>::iterator itr = swapchainImageMap.begin();
     while (itr != swapchainImageMap.end()) {
         OBJTRACK_NODE* pNode = (*itr).second;
-        if (pNode->parentObj == swapchain.handle) {
+        if (pNode->parentObj == (uint64_t) swapchain) {
            swapchainImageMap.erase(itr++);
         } else {
            ++itr;
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 0fa3337..cd91034 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -63,7 +63,7 @@
     VkFormat format;
     VkImage *imageList;
 } SwapchainMapStruct;
-static unordered_map<uint64_t, SwapchainMapStruct *> swapchainMap;
+static unordered_map<VkSwapchainKHR, SwapchainMapStruct *> swapchainMap;
 
 // unordered map: associates an image with a device, image extent, and format
 typedef struct
@@ -72,7 +72,7 @@
     VkExtent2D imageExtent;
     VkFormat format;
 } ImageMapStruct;
-static unordered_map<uint64_t, ImageMapStruct *> imageMap;
+static unordered_map<VkImage, ImageMapStruct *> imageMap;
 
 // unordered map: associates a device with a queue, cmdPool, and physical device
 typedef struct
@@ -140,13 +140,13 @@
     const char *ptr;
     VkDeviceMemory mem2;
     VkCmdBuffer cmdBuffer;
-    VkDevice device = imageMap[image1.handle]->device;
+    VkDevice device = imageMap[image1]->device;
     VkPhysicalDevice physicalDevice = deviceMap[device]->physicalDevice;
     VkInstance instance = physDeviceMap[physicalDevice]->instance;
     VkQueue queue = deviceMap[device]->queue;
-    int width = imageMap[image1.handle]->imageExtent.width;
-    int height = imageMap[image1.handle]->imageExtent.height;
-    VkFormat format = imageMap[image1.handle]->format;
+    int width = imageMap[image1]->imageExtent.width;
+    int height = imageMap[image1]->imageExtent.height;
+    VkFormat format = imageMap[image1]->format;
     const VkImageSubresource sr = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0};
     VkSubresourceLayout sr_layout;
     const VkImageCreateInfo imgCreateInfo = {
@@ -196,7 +196,7 @@
     VkLayerDispatchTable* pTableCmdBuffer;
     VkPhysicalDeviceMemoryProperties memory_properties;
 
-    if (imageMap.empty() || imageMap.find(image1.handle) == imageMap.end())
+    if (imageMap.empty() || imageMap.find(image1) == imageMap.end())
         return;
 
     // The VkImage image1 we are going to dump may not be mappable,
@@ -504,10 +504,10 @@
         swapchainMapElem->device = device;
         swapchainMapElem->imageExtent = pCreateInfo->imageExtent;
         swapchainMapElem->format = pCreateInfo->imageFormat;
-        swapchainMap.insert(make_pair(pSwapchain->handle, swapchainMapElem));
+        swapchainMap.insert(make_pair(*pSwapchain, swapchainMapElem));
 
         // Create a mapping for the swapchain object into the dispatch table
-        screenshot_device_table_map.emplace((void *)pSwapchain->handle, pTable);
+        screenshot_device_table_map.emplace((void *)pSwapchain, pTable);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
 
@@ -531,32 +531,32 @@
 
     if (result == VK_SUCCESS &&
         pSwapchainImages &&
-        !swapchainMap.empty() && swapchainMap.find(swapchain.handle) != swapchainMap.end())
+        !swapchainMap.empty() && swapchainMap.find(swapchain) != swapchainMap.end())
     {
         unsigned i;
 
         for (i=0; i<*pCount; i++)
         {
             // Create a mapping for an image to a device, image extent, and format
-            if (imageMap[pSwapchainImages[i].handle] == NULL)
+            if (imageMap[pSwapchainImages[i]] == NULL)
             {
                 ImageMapStruct *imageMapElem = new ImageMapStruct;
-                imageMap[pSwapchainImages[i].handle] = imageMapElem;
+                imageMap[pSwapchainImages[i]] = imageMapElem;
             }
-            imageMap[pSwapchainImages[i].handle]->device = swapchainMap[swapchain.handle]->device;
-            imageMap[pSwapchainImages[i].handle]->imageExtent = swapchainMap[swapchain.handle]->imageExtent;
-            imageMap[pSwapchainImages[i].handle]->format = swapchainMap[swapchain.handle]->format;
+            imageMap[pSwapchainImages[i]]->device = swapchainMap[swapchain]->device;
+            imageMap[pSwapchainImages[i]]->imageExtent = swapchainMap[swapchain]->imageExtent;
+            imageMap[pSwapchainImages[i]]->format = swapchainMap[swapchain]->format;
         }
 
         // Add list of images to swapchain to image map
-        SwapchainMapStruct *swapchainMapElem = swapchainMap[swapchain.handle];
+        SwapchainMapStruct *swapchainMapElem = swapchainMap[swapchain];
         if (i >= 1 && swapchainMapElem)
         {
             VkImage *imageList = new VkImage[i];
             swapchainMapElem->imageList = imageList;
             for (unsigned j=0; j<i; j++)
             {
-                swapchainMapElem->imageList[j] = pSwapchainImages[j].handle;
+                swapchainMapElem->imageList[j] = pSwapchainImages[j];
             }
         }
 
@@ -615,9 +615,9 @@
             fileName = to_string(frameNumber) + ".ppm";
 
             VkImage image;
-            uint64_t swapchain;
+            VkSwapchainKHR swapchain;
             // We'll dump only one image: the first
-            swapchain = pPresentInfo->swapchains[0].handle;
+            swapchain = pPresentInfo->swapchains[0];
             image = swapchainMap[swapchain]->imageList[pPresentInfo->imageIndices[0]];
             writePPM(fileName.c_str(), image);
             screenshotFrames.erase(it);
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 22bb357..91c0336 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -89,7 +89,7 @@
 static loader_platform_thread_mutex globalLock;
 
 
-std::unordered_map<uint64_t, std::vector<VkDescriptorSetLayoutBinding>*> descriptor_set_layout_map;
+std::unordered_map<VkDescriptorSetLayout, std::vector<VkDescriptorSetLayoutBinding>*> descriptor_set_layout_map;
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
     VkDevice device,
@@ -102,7 +102,7 @@
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        auto& bindings = descriptor_set_layout_map[pSetLayout->handle];
+        auto& bindings = descriptor_set_layout_map[*pSetLayout];
         bindings = new std::vector<VkDescriptorSetLayoutBinding>(
                 pCreateInfo->pBinding, pCreateInfo->pBinding + pCreateInfo->count);
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -112,7 +112,7 @@
 }
 
 
-std::unordered_map<uint64_t, std::vector<std::vector<VkDescriptorSetLayoutBinding>*>*> pipeline_layout_map;
+std::unordered_map<VkPipelineLayout, std::vector<std::vector<VkDescriptorSetLayoutBinding>*>*> pipeline_layout_map;
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
     VkDevice                                    device,
@@ -124,11 +124,11 @@
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
-        auto& layouts = pipeline_layout_map[pPipelineLayout->handle];
+        auto& layouts = pipeline_layout_map[*pPipelineLayout];
         layouts = new std::vector<std::vector<VkDescriptorSetLayoutBinding>*>();
         layouts->reserve(pCreateInfo->descriptorSetCount);
         for (unsigned i = 0; i < pCreateInfo->descriptorSetCount; i++) {
-            layouts->push_back(descriptor_set_layout_map[pCreateInfo->pSetLayouts[i].handle]);
+            layouts->push_back(descriptor_set_layout_map[pCreateInfo->pSetLayouts[i]]);
         }
         loader_platform_thread_unlock_mutex(&globalLock);
     }
@@ -209,7 +209,7 @@
 };
 
 
-static std::unordered_map<uint64_t, shader_module *> shader_module_map;
+static std::unordered_map<VkShaderModule, shader_module *> shader_module_map;
 
 struct shader_object {
     std::string name;
@@ -218,12 +218,12 @@
 
     shader_object(VkShaderCreateInfo const *pCreateInfo)
     {
-        module = shader_module_map[pCreateInfo->module.handle];
+        module = shader_module_map[pCreateInfo->module];
         stage = pCreateInfo->stage;
         name = pCreateInfo->pName;
     }
 };
-static std::unordered_map<uint64_t, shader_object *> shader_object_map;
+static std::unordered_map<VkShader, shader_object *> shader_object_map;
 
 struct render_pass {
     std::vector<std::vector<VkFormat>> subpass_color_formats;
@@ -250,7 +250,7 @@
         }
     }
 };
-static std::unordered_map<uint64_t, render_pass *> render_pass_map;
+static std::unordered_map<VkRenderPass, render_pass *> render_pass_map;
 
 
 static void
@@ -650,7 +650,7 @@
 
     if (res == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
-        shader_module_map[pShaderModule->handle] = new shader_module(pCreateInfo);
+        shader_module_map[*pShaderModule] = new shader_module(pCreateInfo);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
     return res;
@@ -664,7 +664,7 @@
     VkResult res = get_dispatch_table(shader_checker_device_table_map, device)->CreateShader(device, pCreateInfo, pShader);
 
     loader_platform_thread_lock_mutex(&globalLock);
-    shader_object_map[pShader->handle] = new shader_object(pCreateInfo);
+    shader_object_map[*pShader] = new shader_object(pCreateInfo);
     loader_platform_thread_unlock_mutex(&globalLock);
     return res;
 }
@@ -677,7 +677,7 @@
     VkResult res = get_dispatch_table(shader_checker_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass);
 
     loader_platform_thread_lock_mutex(&globalLock);
-    render_pass_map[pRenderPass->handle] = new render_pass(pCreateInfo);
+    render_pass_map[*pRenderPass] = new render_pass(pCreateInfo);
     loader_platform_thread_unlock_mutex(&globalLock);
     return res;
 }
@@ -1080,7 +1080,7 @@
                 }
             }
             else {
-                struct shader_object *shader = shader_object_map[pStage->shader.handle];
+                struct shader_object *shader = shader_object_map[pStage->shader];
                 shaders[get_shader_stage_id(shader->stage)] = shader->module;
 
                 /* validate descriptor set layout against what the spirv module actually uses */
@@ -1088,8 +1088,8 @@
                 collect_interface_by_descriptor_slot(dev, shader->module, spv::StorageClassUniform,
                         descriptor_uses);
 
-                auto layout = pCreateInfo->layout.handle ?
-                    pipeline_layout_map[pCreateInfo->layout.handle] : nullptr;
+                auto layout = pCreateInfo->layout != VK_NULL_HANDLE ?
+                    pipeline_layout_map[pCreateInfo->layout] : nullptr;
 
                 for (auto it = descriptor_uses.begin(); it != descriptor_uses.end(); it++) {
 
@@ -1112,7 +1112,7 @@
     }
 
     if (pCreateInfo->renderPass != VK_NULL_HANDLE)
-        rp = render_pass_map[pCreateInfo->renderPass.handle];
+        rp = render_pass_map[pCreateInfo->renderPass];
 
     vi = pCreateInfo->pVertexInputState;
 
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 38d8e94..0fcac4e 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -53,7 +53,7 @@
 static std::unordered_map<void *, SwpInstance>       instanceMap;
 static std::unordered_map<void *, SwpPhysicalDevice> physicalDeviceMap;
 static std::unordered_map<void *, SwpDevice>         deviceMap;
-static std::unordered_map<uint64_t, SwpSwapchain>    swapchainMap;
+static std::unordered_map<VkSwapchainKHR, SwpSwapchain>    swapchainMap;
 
 
 static void createDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice device)
@@ -830,11 +830,11 @@
             // Remember the swapchain's handle, and link it to the device:
             SwpDevice *pDevice = &deviceMap[device];
 
-            swapchainMap[pSwapchain->handle].swapchain = *pSwapchain;
-            pDevice->swapchains[pSwapchain->handle] =
-                &swapchainMap[pSwapchain->handle];
-            swapchainMap[pSwapchain->handle].pDevice = pDevice;
-            swapchainMap[pSwapchain->handle].imageCount = 0;
+            swapchainMap[*pSwapchain].swapchain = *pSwapchain;
+            pDevice->swapchains[*pSwapchain] =
+                &swapchainMap[*pSwapchain];
+            swapchainMap[*pSwapchain].pDevice = pDevice;
+            swapchainMap[*pSwapchain].imageCount = 0;
         }
 
         return result;
@@ -864,11 +864,11 @@
     }
 
     // Regardless of skipCall value, do some internal cleanup:
-    SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
+    SwpSwapchain *pSwapchain = &swapchainMap[swapchain];
     if (pSwapchain) {
         // Delete the SwpSwapchain associated with this swapchain:
         if (pSwapchain->pDevice) {
-            pSwapchain->pDevice->swapchains.erase(swapchain.handle);
+            pSwapchain->pDevice->swapchains.erase(swapchain);
             if (device != pSwapchain->pDevice->device) {
                 LOG_ERROR(VK_OBJECT_TYPE_DEVICE, device, "VkDevice",
                           SWAPCHAIN_DESTROY_SWAP_DIFF_DEVICE,
@@ -880,10 +880,10 @@
         if (pSwapchain->imageCount) {
             pSwapchain->images.clear();
         }
-        swapchainMap.erase(swapchain.handle);
+        swapchainMap.erase(swapchain);
     } else {
         skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-                                            swapchain.handle,
+                                            swapchain,
                                             "VkSwapchainKHR");
     }
 
@@ -916,7 +916,7 @@
                               "extension was not enabled for this VkDevice.",
                               __FUNCTION__);
     }
-    SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
+    SwpSwapchain *pSwapchain = &swapchainMap[swapchain];
     if (!pSwapchain) {
         skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
                                             swapchain.handle,
@@ -973,10 +973,10 @@
                               __FUNCTION__);
     }
     // Validate that a valid VkSwapchainKHR was used:
-    SwpSwapchain *pSwapchain = &swapchainMap[swapchain.handle];
+    SwpSwapchain *pSwapchain = &swapchainMap[swapchain];
     if (!pSwapchain) {
         skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-                                            swapchain.handle,
+                                            swapchain,
                                             "VkSwapchainKHR");
     } else {
         // Look to see if the application is trying to own too many images at
@@ -1037,7 +1037,7 @@
     for (uint32_t i = 0; i < pPresentInfo->swapchainCount ; i++) {
         uint32_t index = pPresentInfo->imageIndices[i];
         SwpSwapchain *pSwapchain =
-            &swapchainMap[pPresentInfo->swapchains[i].handle];
+            &swapchainMap[pPresentInfo->swapchains[i]];
         if (pSwapchain) {
             if (!pSwapchain->pDevice->deviceSwapchainExtensionEnabled) {
                 skipCall |= LOG_ERROR(VK_OBJECT_TYPE_DEVICE,
@@ -1051,7 +1051,7 @@
             }
             if (index >= pSwapchain->imageCount) {
                 skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-                                      pPresentInfo->swapchains[i].handle,
+                                      pPresentInfo->swapchains[i],
                                       "VkSwapchainKHR",
                                       SWAPCHAIN_INDEX_TOO_LARGE,
                                       "%s() called for an index that is too "
@@ -1062,7 +1062,7 @@
             } else {
                 if (!pSwapchain->images[index].ownedByApp) {
                     skipCall |= LOG_ERROR(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-                                          pPresentInfo->swapchains[i].handle,
+                                          pPresentInfo->swapchains[i],
                                           "VkSwapchainKHR",
                                           SWAPCHAIN_INDEX_NOT_IN_USE,
                                           "%s() returned an index (i.e. %d) "
@@ -1073,7 +1073,7 @@
             }
         } else {
             skipCall |= LOG_ERROR_NON_VALID_OBJ(VK_OBJECT_TYPE_SWAPCHAIN_KHR,
-                                                pPresentInfo->swapchains[i].handle,
+                                                pPresentInfo->swapchains[i],
                                                 "VkSwapchainKHR");
         }
     }
@@ -1087,7 +1087,7 @@
             for (uint32_t i = 0; i < pPresentInfo->swapchainCount ; i++) {
                 int index = pPresentInfo->imageIndices[i];
                 SwpSwapchain *pSwapchain =
-                    &swapchainMap[pPresentInfo->swapchains[i].handle];
+                    &swapchainMap[pPresentInfo->swapchains[i]];
                 if (pSwapchain) {
                     // Change the state of the image (no longer owned by the
                     // application):
diff --git a/layers/swapchain.h b/layers/swapchain.h
index 21a2fe6..18dc363 100644
--- a/layers/swapchain.h
+++ b/layers/swapchain.h
@@ -183,7 +183,7 @@
 
     // When vkCreateSwapchainKHR is called, the VkSwapchainKHR's are
     // remembered:
-    unordered_map<uint64_t, SwpSwapchain*> swapchains;
+    unordered_map<VkSwapchainKHR, SwpSwapchain*> swapchains;
 };
 
 // Create one of these for each VkImage within a VkSwapchainKHR:
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index 60d3fb1..70894f7 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -119,7 +119,7 @@
 
         debug_report_log_msg(
                     debug_data, VK_DBG_REPORT_WARN_BIT,
-                    VK_OBJECT_TYPE_MSG_CALLBACK, pTrav->msgCallback.handle,
+                    VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) pTrav->msgCallback,
                     0, DEBUG_REPORT_CALLBACK_REF,
                     "DebugReport",
                     "Debug Report callbacks not removed before DestroyInstance");
@@ -159,7 +159,7 @@
 
     // Handle of 0 is logging_callback so use allocated Node address as unique handle
     if (!(*pMsgCallback))
-        *pMsgCallback = (uint64_t) pNewDbgFuncNode;
+        *pMsgCallback = (VkDbgMsgCallback) pNewDbgFuncNode;
     pNewDbgFuncNode->msgCallback = *pMsgCallback;
     pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
     pNewDbgFuncNode->msgFlags = msgFlags;
@@ -171,7 +171,7 @@
 
     debug_report_log_msg(
                 debug_data, VK_DBG_REPORT_DEBUG_BIT,
-                VK_OBJECT_TYPE_MSG_CALLBACK, (*pMsgCallback).handle,
+                VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) *pMsgCallback,
                 0, DEBUG_REPORT_CALLBACK_REF,
                 "DebugReport",
                 "Added callback");
@@ -196,7 +196,7 @@
             }
             debug_report_log_msg(
                         debug_data, VK_DBG_REPORT_DEBUG_BIT,
-                        VK_OBJECT_TYPE_MSG_CALLBACK, pTrav->msgCallback.handle,
+                        VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) pTrav->msgCallback,
                         0, DEBUG_REPORT_NONE,
                         "DebugReport",
                         "Destroyed callback");
diff --git a/loader/debug_report.c b/loader/debug_report.c
index f73929a..00069b1 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -107,7 +107,7 @@
     VkResult result = inst->disp->DbgDestroyMsgCallback(instance, msg_callback);
 
     while (pTrav) {
-        if (pTrav->msgCallback.handle == msg_callback.handle) {
+        if (pTrav->msgCallback == msg_callback) {
             pPrev->pNext = pTrav->pNext;
             if (inst->DbgFunctionHead == pTrav)
                 inst->DbgFunctionHead = pTrav->pNext;
@@ -174,7 +174,7 @@
     if (icd) {
         storage_idx = 0;
         for (icd = inst->icds; icd; icd = icd->next) {
-            if (icd_info[storage_idx].handle) {
+            if (icd_info[storage_idx]) {
                 icd->DbgDestroyMsgCallback(
                       icd->instance,
                       icd_info[storage_idx]);
@@ -212,7 +212,7 @@
     icd_info = *(VkDbgMsgCallback **) &msgCallback;
     storage_idx = 0;
     for (icd = inst->icds; icd; icd = icd->next) {
-        if (icd_info[storage_idx].handle) {
+        if (icd_info[storage_idx]) {
             icd->DbgDestroyMsgCallback(
                   icd->instance,
                   icd_info[storage_idx]);
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 8e120ba..f98b068 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -1102,8 +1102,7 @@
     err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
-    VkBufferView view;
-    view.handle = 0xbaadbeef; // invalid bufferView object
+    VkBufferView view = (VkBufferView) 0xbaadbeef; // invalid bufferView object
 
     VkWriteDescriptorSet descriptor_write;
     memset(&descriptor_write, 0, sizeof(descriptor_write));
@@ -1739,7 +1738,6 @@
     std::string     msgString;
     VkResult        err;
     VkCmdBuffer     draw_cmd;
-    VkCmdPool       cmd_pool;
 
     ASSERT_NO_FATAL_FAILURE(InitState());
     m_errorMonitor->ClearState();
@@ -3272,8 +3270,7 @@
     err = vkAllocDescriptorSets(m_device->device(), &alloc_info, &descriptorSet);
     ASSERT_VK_SUCCESS(err);
 
-    VkSampler sampler;
-    sampler.handle = 0xbaadbeef; // Sampler with invalid handle
+    VkSampler sampler = (VkSampler) 0xbaadbeef; // Sampler with invalid handle
 
     VkDescriptorImageInfo descriptor_info;
     memset(&descriptor_info, 0, sizeof(VkDescriptorImageInfo));
@@ -3370,8 +3367,7 @@
     err = vkCreateSampler(m_device->device(), &sampler_ci, &sampler);
     ASSERT_VK_SUCCESS(err);
 
-    VkImageView view;
-    view.handle = 0xbaadbeef; // invalid imageView object
+    VkImageView view = (VkImageView) 0xbaadbeef; // invalid imageView object
 
     VkDescriptorImageInfo descriptor_info;
     memset(&descriptor_info, 0, sizeof(VkDescriptorImageInfo));
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index f320460..0551600 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -927,7 +927,7 @@
     swap_chain.queueFamilyCount = 0;
     swap_chain.pQueueFamilyIndices = NULL;
     swap_chain.presentMode = swapchainPresentMode;
-    swap_chain.oldSwapchain.handle = 0;
+    swap_chain.oldSwapchain = VK_NULL_HANDLE;
     swap_chain.clipped = true;
 
     uint32_t i;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 189360d..afcf4be 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -127,8 +127,8 @@
             return ("%lu", name)
         if vk_type.strip('*') in vulkan.object_non_dispatch_list:
             if '*' in vk_type:
-                return ("%lu", "%s->handle" % name)
-            return ("%lu", "%s.handle" % name)
+                return ("%lu", "%s" % name)
+            return ("%lu", "%s" % name)
         if "size" in vk_type:
             if '*' in vk_type:
                 return ("%lu", "(unsigned long)*%s" % name)
@@ -994,9 +994,9 @@
                         cp = True
             (pft, pfi) = self._get_printf_params(p.ty, p.name, cp, cpp=True)
             if p.name == "pSwapchain" or p.name == "pSwapchainImages":
-                log_func += '%s = " << ((%s == NULL) ? 0 : %s->handle) << ", ' % (p.name, p.name, p.name)
+                log_func += '%s = " << %s << ", ' % (p.name, p.name)
             elif p.name == "swapchain":
-                log_func += '%s = " << %s.handle << ", ' % (p.name, p.name)
+                log_func += '%s = " << %s << ", ' % (p.name, p.name)
             else:
                 log_func += '%s = " << %s << ", ' % (p.name, pfi)
             if "%p" == pft:
@@ -1067,10 +1067,7 @@
                         print_cast = ''
                         print_func = 'string_convert_helper'
                         #cis_print_func = 'tmp_str = string_convert_helper((void*)%s[i], "    ");' % proto.params[sp_index].name
-                    if proto.params[sp_index].ty.strip('*').replace('const ', '') in vulkan.object_non_dispatch_list:
-                        cis_print_func = 'tmp_str = %s(%s%s[i].handle, "    ");' % (print_func, print_cast, proto.params[sp_index].name)
-                    else:
-                        cis_print_func = 'tmp_str = %s(%s%s[i], "    ");' % (print_func, print_cast, proto.params[sp_index].name)
+                    cis_print_func = 'tmp_str = %s(%s%s[i], "    ");' % (print_func, print_cast, proto.params[sp_index].name)
                     if not i_decl:
                         log_func += '\n%suint32_t i;' % (indent)
                         i_decl = True
@@ -1215,26 +1212,18 @@
             procs_txt.append('%s' % self.lineinfo.get())
             if o in vulkan.object_dispatch_list:
                 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<uint64_t>(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<uint64_t>(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('        vkObj.handle);')
+            procs_txt.append('{')
+            procs_txt.append('    log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, objType, reinterpret_cast<uint64_t>(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<uint64_t>(vkObj));')
             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 vulkan.object_dispatch_list:
-                procs_txt.append('    pNewObjNode->vkObj  = reinterpret_cast<uint64_t>(vkObj);')
-                procs_txt.append('    %sMap[vkObj] = pNewObjNode;' % (o))
-            else:
-                procs_txt.append('    pNewObjNode->vkObj  = vkObj.handle;')
-                procs_txt.append('    %sMap[(void*)vkObj.handle] = pNewObjNode;' % (o))
+            procs_txt.append('    pNewObjNode->vkObj  = reinterpret_cast<uint64_t>(vkObj);')
+            procs_txt.append('    %sMap[vkObj] = pNewObjNode;' % (o))
             procs_txt.append('    uint32_t objIndex = objTypeToIndex(objType);')
             procs_txt.append('    numObjs[objIndex]++;')
             procs_txt.append('    numTotalObjs++;')
@@ -1263,12 +1252,12 @@
                     procs_txt.append('')
                 if o == "VkImage":
                     procs_txt.append('    // We need to validate normal image objects and those from the swapchain')
-                    procs_txt.append('    if ((%sMap.find((void*)object.handle)        == %sMap.end()) &&' % (o, o))
-                    procs_txt.append('        (swapchainImageMap.find((void*)object.handle) == swapchainImageMap.end())) {')
+                    procs_txt.append('    if ((%sMap.find((void*)object)        == %sMap.end()) &&' % (o, o))
+                    procs_txt.append('        (swapchainImageMap.find((void*)object) == swapchainImageMap.end())) {')
                 else:
-                    procs_txt.append('    if (%sMap.find((void*)object.handle) == %sMap.end()) {' % (o, o))
-                procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
-                procs_txt.append('            "Invalid %s Object %%p", object.handle);' % o)
+                    procs_txt.append('    if (%sMap.find((void*)object) == %sMap.end()) {' % (o, o))
+                procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+                procs_txt.append('            "Invalid %s Object %%p", object);' % o)
             procs_txt.append('    }')
             procs_txt.append('    return VK_FALSE;')
             procs_txt.append('}')
@@ -1280,68 +1269,42 @@
             else:
                 procs_txt.append('static void destroy_obj(VkDevice dispatchable_object, %s object)' % (o))
             procs_txt.append('{')
-            if o in vulkan.object_dispatch_list:
-                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 (%sMap.find(object) != %sMap.end()) {' % (o, o))
+            procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object];' % (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 vulkan.object_dispatch_list:
-                procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, reinterpret_cast<uint64_t>(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<uint64_t>(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), object.handle, numTotalObjs, numObjs[objIndex],')
+            procs_txt.append('        log_msg(mdd(dispatchable_object), VK_DBG_REPORT_INFO_BIT, pNode->objType, reinterpret_cast<uint64_t>(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<uint64_t>(object), numTotalObjs, numObjs[objIndex],')
             procs_txt.append('            string_VkDbgObjectType(pNode->objType));')
             procs_txt.append('        delete pNode;')
-            if o in vulkan.object_dispatch_list:
-                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<uint64_t>(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<uint64_t>(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('            object.handle);')
-                procs_txt.append('    }')
+            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<uint64_t>(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<uint64_t>(object));')
+            procs_txt.append('    }')
             procs_txt.append('}')
             procs_txt.append('')
             procs_txt.append('%s' % self.lineinfo.get())
             if o in vulkan.object_dispatch_list:
                 procs_txt.append('static VkBool32 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 VkBool32 set_status(VkDevice dispatchable_object, %s object, VkDbgObjectType objType, ObjectStatusFlags status_flag)' % (o))
-                procs_txt.append('{')
-                procs_txt.append('    if (object != 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('{')
+            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))
             procs_txt.append('            pNode->status |= status_flag;')
             procs_txt.append('        }')
             procs_txt.append('        else {')
             procs_txt.append('            // If we do not find it print an error')
-            if o in vulkan.object_dispatch_list:
-                procs_txt.append('            return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(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<uint64_t>(object), string_VkDbgObjectType(objType));')
-            else:
-                procs_txt.append('            return 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('                object.handle, string_VkDbgObjectType(objType));')
+            procs_txt.append('            return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(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<uint64_t>(object), string_VkDbgObjectType(objType));')
             procs_txt.append('        }')
             procs_txt.append('    }')
             procs_txt.append('    return VK_FALSE;')
@@ -1360,35 +1323,21 @@
             procs_txt.append('    OBJECT_TRACK_ERROR  error_code,')
             procs_txt.append('    const char         *fail_msg)')
             procs_txt.append('{')
-            if o in vulkan.object_dispatch_list:
-                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 (%sMap.find(object) != %sMap.end()) {' % (o, o))
+            procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object];' % (o))
             procs_txt.append('        if ((pNode->status & status_mask) != status_flag) {')
-            if o in vulkan.object_dispatch_list:
-                procs_txt.append('            log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, reinterpret_cast<uint64_t>(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<uint64_t>(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('                 object.handle, fail_msg);')
+            procs_txt.append('            log_msg(mdd(dispatchable_object), msg_flags, pNode->objType, reinterpret_cast<uint64_t>(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<uint64_t>(object), 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 vulkan.object_dispatch_list:
-                procs_txt.append('        log_msg(mdd(dispatchable_object), msg_flags, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(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<uint64_t>(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('            object.handle, string_VkDbgObjectType(objType));')
+            procs_txt.append('        log_msg(mdd(dispatchable_object), msg_flags, (VkDbgObjectType) 0, reinterpret_cast<uint64_t>(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<uint64_t>(object), string_VkDbgObjectType(objType));')
             procs_txt.append('        return VK_FALSE;')
             procs_txt.append('    }')
             procs_txt.append('}')
@@ -1396,26 +1345,18 @@
             procs_txt.append('%s' % self.lineinfo.get())
             if o in vulkan.object_dispatch_list:
                 procs_txt.append('static VkBool32 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 VkBool32 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('{')
+            procs_txt.append('    if (%sMap.find(object) != %sMap.end()) {' % (o, o))
+            procs_txt.append('        OBJTRACK_NODE* pNode = %sMap[object];' % (o))
             procs_txt.append('        pNode->status &= ~status_flag;')
             procs_txt.append('    }')
             procs_txt.append('    else {')
             procs_txt.append('        // If we do not find it print an error')
-            if o in vulkan.object_dispatch_list:
-                procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, reinterpret_cast<uint64_t>(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<uint64_t>(object), string_VkDbgObjectType(objType));')
-            else:
-                procs_txt.append('        return 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('            object.handle, string_VkDbgObjectType(objType));')
+            procs_txt.append('        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, objType, reinterpret_cast<uint64_t>(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<uint64_t>(object), string_VkDbgObjectType(objType));')
             procs_txt.append('    }')
             procs_txt.append('    return VK_FALSE;')
             procs_txt.append('}')
@@ -1517,9 +1458,9 @@
                   'VkPipelineLayout', 'VkBuffer', 'VkEvent', 'VkQueryPool', 'VkRenderPass', 'VkFramebuffer']:
             cbv_txt.append('static VkBool32 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('        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, object.handle, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
-            cbv_txt.append('            "Invalid %s Object %%p", object.handle);' % (o))
+            cbv_txt.append('    if (%sMap.find((void*)object) == %sMap.end()) {' % (o, o))
+            cbv_txt.append('        return log_msg(mdd(dispatchable_object), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, (uint64_t) object, 0, OBJTRACK_INVALID_OBJECT, "OBJTRACK",')
+            cbv_txt.append('            "Invalid %s Object %%p", object);' % (o))
             cbv_txt.append('    }')
             cbv_txt.append('    return VK_FALSE;')
             cbv_txt.append('}')
@@ -1776,12 +1717,8 @@
     }
     def generate_useObject(self, ty):
         obj_type = self.thread_check_object_types[ty]
-        if ty in self.thread_check_dispatchable_objects:
-            key = "object"
-            msg_object = "reinterpret_cast<uint64_t>(object)"
-        else:
-            key = "object.handle"
-            msg_object = "object.handle"
+        key = "object"
+        msg_object = "reinterpret_cast<uint64_t>(object)"
         header_txt = []
         header_txt.append('%s' % self.lineinfo.get())
         header_txt.append('static void useObject(const void* dispatchable_object, %s object)' % ty)
@@ -1812,10 +1749,7 @@
         header_txt.append('}')
         return "\n".join(header_txt)
     def generate_finishUsingObject(self, ty):
-        if ty in self.thread_check_dispatchable_objects:
-            key = "object"
-        else:
-            key = "object.handle"
+        key = "object"
         header_txt = []
         header_txt.append('%s' % self.lineinfo.get())
         header_txt.append('static void finishUsingObject(%s object)' % ty)
@@ -1851,7 +1785,7 @@
         for ty in self.thread_check_dispatchable_objects:
             header_txt.append('static unordered_map<%s, loader_platform_thread_id> %sObjectsInUse;' % (ty, ty))
         for ty in self.thread_check_nondispatchable_objects:
-            header_txt.append('static unordered_map<uint64_t, loader_platform_thread_id> %sObjectsInUse;' % ty)
+            header_txt.append('static unordered_map<%s, loader_platform_thread_id> %sObjectsInUse;' % (ty, ty))
         header_txt.append('static int threadingLockInitialized = 0;')
         header_txt.append('static loader_platform_thread_mutex threadingLock;')
         header_txt.append('static loader_platform_thread_cond threadingCond;')
diff --git a/vk_helper.py b/vk_helper.py
index 9cf8c04..122db6b 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -953,7 +953,7 @@
                         if "addr" in po: # or self.struct_dict[s][m]['ptr']:
                             sh_funcs.append('    ss[%u].str("addr");' % (index))
                         elif not self.struct_dict[s][m]['ptr'] and self.struct_dict[s][m]['type'] in vulkan.core.objects:
-                            sh_funcs.append('    ss[%u] << pStruct->%s.handle;' % (index, self.struct_dict[s][m]['name']))
+                            sh_funcs.append('    ss[%u] << pStruct->%s;' % (index, self.struct_dict[s][m]['name']))
                         else:
                             sh_funcs.append('    ss[%u] << pStruct->%s;' % (index, self.struct_dict[s][m]['name']))
                     value_print = 'ss[%u].str()' % index