Bug 14084 - Improve type safety and remove polymorphism

6 files changed, 442 insertions, 61 deletions

diff --git a/loader/debug_report.c b/loader/debug_report.c
index 89340e6b..4d6314a9 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -108,7 +108,7 @@ static VkResult debug_report_DbgDestroyMsgCallback(
     VkResult result = inst->disp->DbgDestroyMsgCallback(instance, msg_callback);
 
     while (pTrav) {
-        if (pTrav->msgCallback == msg_callback) {
+        if (pTrav->msgCallback.handle == msg_callback.handle) {
             pPrev->pNext = pTrav->pNext;
             if (inst->DbgFunctionHead == pTrav)
                 inst->DbgFunctionHead = pTrav->pNext;
@@ -128,6 +128,7 @@ static VkResult debug_report_DbgDestroyMsgCallback(
  * This is the instance chain terminator function
  * for DbgCreateMsgCallback
  */
+
 VkResult loader_DbgCreateMsgCallback(
         VkInstance                          instance,
         VkFlags                             msgFlags,
@@ -180,7 +181,7 @@ VkResult loader_DbgCreateMsgCallback(
     if (icd) {
         storage_idx = 0;
         for (icd = inst->icds; icd; icd = icd->next) {
-            if (icd_info[storage_idx]) {
+            if (icd_info[storage_idx].handle) {
                 icd->DbgDestroyMsgCallback(
                       icd->instance,
                       icd_info[storage_idx]);
@@ -191,7 +192,7 @@ VkResult loader_DbgCreateMsgCallback(
         return res;
     }
 
-    *pMsgCallback = (VkDbgMsgCallback) icd_info;
+    *(VkDbgMsgCallback **)pMsgCallback = icd_info;
 
     return VK_SUCCESS;
 }
@@ -221,10 +222,10 @@ VkResult loader_DbgDestroyMsgCallback(
     if (inst == VK_NULL_HANDLE)
         return VK_ERROR_INVALID_HANDLE;
 
-    icd_info = (VkDbgMsgCallback *) msgCallback;
+    icd_info = *(VkDbgMsgCallback **) &msgCallback;
     storage_idx = 0;
     for (icd = inst->icds; icd; icd = icd->next) {
-        if (icd_info[storage_idx]) {
+        if (icd_info[storage_idx].handle) {
             icd->DbgDestroyMsgCallback(
                   icd->instance,
                   icd_info[storage_idx]);
@@ -267,8 +268,8 @@ static void print_msg_flags(VkFlags msgFlags, char *msg_flags)
 // DebugReport utility callback functions
 static void VKAPI StringCallback(
     VkFlags                             msgFlags,
-    VkObjectType                        objType,
-    VkObject                            srcObject,
+    VkDbgObjectType                     objType,
+    uint64_t                            srcObject,
     size_t                              location,
     int32_t                             msgCode,
     const char*                         pLayerPrefix,
@@ -302,8 +303,8 @@ static void VKAPI StringCallback(
 
 static void VKAPI StdioCallback(
     VkFlags                             msgFlags,
-    VkObjectType                        objType,
-    VkObject                            srcObject,
+    VkDbgObjectType                     objType,
+    uint64_t                            srcObject,
     size_t                              location,
     int32_t                             msgCode,
     const char*                         pLayerPrefix,
@@ -320,8 +321,8 @@ static void VKAPI StdioCallback(
 
 static void VKAPI BreakCallback(
     VkFlags                             msgFlags,
-    VkObjectType                        objType,
-    VkObject                            srcObject,
+    VkDbgObjectType                     objType,
+    uint64_t                            srcObject,
     size_t                              location,
     int32_t                             msgCode,
     const char*                         pLayerPrefix,
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index 6da2fcc4..04f97dae 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -91,12 +91,14 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkFlushMappedMemoryRanges;
     if (!strcmp(name, "InvalidateMappedMemoryRanges"))
         return (void*) vkInvalidateMappedMemoryRanges;
-    if (!strcmp(name, "DestroyObject"))
-        return (void*) vkDestroyObject;
-    if (!strcmp(name, "GetObjectMemoryRequirements"))
-        return (void*) vkGetObjectMemoryRequirements;
-    if (!strcmp(name, "BindObjectMemory"))
-        return (void*) vkBindObjectMemory;
+    if (!strcmp(name, "GetImageMemoryRequirements"))
+        return (void*) vkGetImageMemoryRequirements;
+    if (!strcmp(name, "GetBufferMemoryRequirements"))
+        return (void*) vkGetBufferMemoryRequirements;
+    if (!strcmp(name, "BindImageMemory"))
+        return (void*) vkBindImageMemory;
+    if (!strcmp(name, "BindBufferMemory"))
+        return (void*) vkBindBufferMemory;
     if (!strcmp(name, "QueueBindSparseBufferMemory"))
         return (void*) vkQueueBindSparseBufferMemory;
     if (!strcmp(name, "QueueBindSparseImageMemory"))
@@ -107,6 +109,8 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkGetImageSparseMemoryRequirements;
     if (!strcmp(name, "CreateFence"))
         return (void*) vkCreateFence;
+    if (!strcmp(name, "DestroyFence"))
+        return (void*) vkDestroyFence;
     if (!strcmp(name, "ResetFences"))
         return (void*) vkResetFences;
     if (!strcmp(name, "GetFenceStatus"))
@@ -115,12 +119,16 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkWaitForFences;
     if (!strcmp(name, "CreateSemaphore"))
         return (void*) vkCreateSemaphore;
+    if (!strcmp(name, "DestroySemaphore"))
+        return (void*) vkDestroySemaphore;
     if (!strcmp(name, "QueueSignalSemaphore"))
         return (void*) vkQueueSignalSemaphore;
     if (!strcmp(name, "QueueWaitSemaphore"))
         return (void*) vkQueueWaitSemaphore;
     if (!strcmp(name, "CreateEvent"))
         return (void*) vkCreateEvent;
+    if (!strcmp(name, "DestroyEvent"))
+        return (void*) vkDestroyEvent;
     if (!strcmp(name, "GetEventStatus"))
         return (void*) vkGetEventStatus;
     if (!strcmp(name, "SetEvent"))
@@ -129,24 +137,40 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkResetEvent;
     if (!strcmp(name, "CreateQueryPool"))
         return (void*) vkCreateQueryPool;
+    if (!strcmp(name, "DestroyQueryPool"))
+        return (void*) vkDestroyQueryPool;
     if (!strcmp(name, "GetQueryPoolResults"))
         return (void*) vkGetQueryPoolResults;
     if (!strcmp(name, "CreateBuffer"))
         return (void*) vkCreateBuffer;
+    if (!strcmp(name, "DestroyBuffer"))
+        return (void*) vkDestroyBuffer;
     if (!strcmp(name, "CreateBufferView"))
         return (void*) vkCreateBufferView;
+    if (!strcmp(name, "DestroyBufferView"))
+        return (void*) vkDestroyBufferView;
     if (!strcmp(name, "CreateImage"))
         return (void*) vkCreateImage;
+    if (!strcmp(name, "DestroyImage"))
+        return (void*) vkDestroyImage;
     if (!strcmp(name, "GetImageSubresourceLayout"))
         return (void*) vkGetImageSubresourceLayout;
     if (!strcmp(name, "CreateImageView"))
         return (void*) vkCreateImageView;
+    if (!strcmp(name, "DestroyImageView"))
+        return (void*) vkDestroyImageView;
     if (!strcmp(name, "CreateAttachmentView"))
         return (void*) vkCreateAttachmentView;
+    if (!strcmp(name, "DestroyAttachmentView"))
+        return (void*) vkDestroyAttachmentView;
     if (!strcmp(name, "CreateShaderModule"))
         return (void*) vkCreateShaderModule;
+    if (!strcmp(name, "DestroyShaderModule"))
+        return (void*) vkDestroyShaderModule;
     if (!strcmp(name, "CreateShader"))
         return (void*) vkCreateShader;
+    if (!strcmp(name, "DestroyShader"))
+        return (void*) vkDestroyShader;
     if (!strcmp(name, "CreatePipelineCache"))
         return (void*) vkCreatePipelineCache;
     if (!strcmp(name, "DestroyPipelineCache"))
@@ -161,14 +185,24 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkCreateGraphicsPipelines;
     if (!strcmp(name, "CreateComputePipelines"))
         return (void*) vkCreateComputePipelines;
+    if (!strcmp(name, "DestroyPipeline"))
+        return (void*) vkDestroyPipeline;
     if (!strcmp(name, "CreatePipelineLayout"))
         return (void*) vkCreatePipelineLayout;
+    if (!strcmp(name, "DestroyPipelineLayout"))
+        return (void*) vkDestroyPipelineLayout;
     if (!strcmp(name, "CreateSampler"))
         return (void*) vkCreateSampler;
+    if (!strcmp(name, "DestroySampler"))
+        return (void*) vkDestroySampler;
     if (!strcmp(name, "CreateDescriptorSetLayout"))
         return (void*) vkCreateDescriptorSetLayout;
+    if (!strcmp(name, "DestroyDescriptorSetLayout"))
+        return (void*) vkDestroyDescriptorSetLayout;
     if (!strcmp(name, "CreateDescriptorPool"))
         return (void*) vkCreateDescriptorPool;
+    if (!strcmp(name, "DestroyDescriptorPool"))
+        return (void*) vkDestroyDescriptorPool;
     if (!strcmp(name, "ResetDescriptorPool"))
         return (void*) vkResetDescriptorPool;
     if (!strcmp(name, "AllocDescriptorSets"))
@@ -177,14 +211,24 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkUpdateDescriptorSets;
     if (!strcmp(name, "CreateDynamicViewportState"))
         return (void*) vkCreateDynamicViewportState;
+    if (!strcmp(name, "DestroyDynamicViewportState"))
+        return (void*) vkDestroyDynamicViewportState;
     if (!strcmp(name, "CreateDynamicRasterState"))
         return (void*) vkCreateDynamicRasterState;
+    if (!strcmp(name, "DestroyDynamicRasterState"))
+        return (void*) vkDestroyDynamicRasterState;
     if (!strcmp(name, "CreateDynamicColorBlendState"))
         return (void*) vkCreateDynamicColorBlendState;
+    if (!strcmp(name, "DestroyDynamicColorBlendState"))
+        return (void*) vkDestroyDynamicColorBlendState;
     if (!strcmp(name, "CreateDynamicDepthStencilState"))
         return (void*) vkCreateDynamicDepthStencilState;
+    if (!strcmp(name, "DestroyDynamicDepthStencilState"))
+        return (void*) vkDestroyDynamicDepthStencilState;
     if (!strcmp(name, "CreateCommandBuffer"))
         return (void*) vkCreateCommandBuffer;
+    if (!strcmp(name, "DestroyCommandBuffer"))
+        return (void*) vkDestroyCommandBuffer;
     if (!strcmp(name, "BeginCommandBuffer"))
         return (void*) vkBeginCommandBuffer;
     if (!strcmp(name, "EndCommandBuffer"))
@@ -193,8 +237,14 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkResetCommandBuffer;
     if (!strcmp(name, "CmdBindPipeline"))
         return (void*) vkCmdBindPipeline;
-    if (!strcmp(name, "CmdBindDynamicStateObject"))
-        return (void*) vkCmdBindDynamicStateObject;
+    if (!strcmp(name, "CmdBindDynamicViewportState"))
+        return (void*) vkCmdBindDynamicViewportState;
+    if (!strcmp(name, "CmdBindDynamicRasterState"))
+        return (void*) vkCmdBindDynamicRasterState;
+    if (!strcmp(name, "CmdBindDynamicColorBlendState"))
+        return (void*) vkCmdBindDynamicColorBlendState;
+    if (!strcmp(name, "CmdBindDynamicDepthStencilState"))
+        return (void*) vkCmdBindDynamicDepthStencilState;
     if (!strcmp(name, "CmdBindDescriptorSets"))
         return (void*) vkCmdBindDescriptorSets;
     if (!strcmp(name, "CmdBindVertexBuffers"))
@@ -257,8 +307,12 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkCmdCopyQueryPoolResults;
     if (!strcmp(name, "CreateFramebuffer"))
         return (void*) vkCreateFramebuffer;
+    if (!strcmp(name, "DestroyFramebuffer"))
+        return (void*) vkDestroyFramebuffer;
     if (!strcmp(name, "CreateRenderPass"))
         return (void*) vkCreateRenderPass;
+    if (!strcmp(name, "DestroyRenderPass"))
+        return (void*) vkDestroyRenderPass;
     if (!strcmp(name, "CmdBeginRenderPass"))
         return (void*) vkCmdBeginRenderPass;
     if (!strcmp(name, "CmdNextSubpass"))
diff --git a/loader/loader.c b/loader/loader.c
index 06384b64..c9333de3 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -951,10 +951,10 @@ static struct loader_icd *loader_icd_add(
 static void loader_scanned_icd_add(const char *filename)
 {
     loader_platform_dl_handle handle;
-    void *fp_create_inst;
-    void *fp_get_global_ext_props;
-    void *fp_get_device_ext_props;
-    PFN_vkGPA fp_get_proc_addr;
+    PFN_vkCreateInstance fp_create_inst;
+    PFN_vkGetGlobalExtensionProperties fp_get_global_ext_props;
+    PFN_vkGetPhysicalDeviceExtensionProperties fp_get_device_ext_props;
+    PFN_vkGetDeviceProcAddr fp_get_proc_addr;
     struct loader_scanned_icds *new_node;
 
     // Used to call: dlopen(filename, RTLD_LAZY);
@@ -2060,8 +2060,8 @@ uint32_t loader_activate_instance_layers(struct loader_instance *inst)
     }
 
     // NOTE inst is unwrapped at this point in time
-    VkObject baseObj = (VkObject) inst;
-    VkObject nextObj = (VkObject) inst;
+    void* baseObj = (void*) inst;
+    void* nextObj = (void*) inst;
     VkBaseLayerObject *nextInstObj;
     PFN_vkGetInstanceProcAddr nextGPA = loader_gpa_instance_internal;
 
@@ -2097,10 +2097,10 @@ uint32_t loader_activate_instance_layers(struct loader_instance *inst)
          * the given baseObject.
          */
         nextInstObj = (wrappedInstance + layer_idx);
-        nextInstObj->pGPA = nextGPA;
+        nextInstObj->pGPA = (PFN_vkGPA) nextGPA;
         nextInstObj->baseObject = baseObj;
         nextInstObj->nextObject = nextObj;
-        nextObj = (VkObject) nextInstObj;
+        nextObj = (void*) nextInstObj;
 
         char funcStr[256];
         snprintf(funcStr, 256, "%sGetInstanceProcAddr", layer_prop->info.layerName);
@@ -2217,8 +2217,8 @@ static uint32_t loader_activate_device_layers(
     }
 
     /* activate any layer libraries */
-    VkObject nextObj = (VkObject) device;
-    VkObject baseObj = nextObj;
+    void* nextObj = (void*) device;
+    void* baseObj = nextObj;
     VkBaseLayerObject *nextGpuObj;
     PFN_vkGetDeviceProcAddr nextGPA = loader_GetDeviceChainProcAddr;
     VkBaseLayerObject *wrappedGpus;
@@ -2238,10 +2238,10 @@ static uint32_t loader_activate_device_layers(
         loader_platform_dl_handle lib_handle;
 
         nextGpuObj = (wrappedGpus + i);
-        nextGpuObj->pGPA = nextGPA;
+        nextGpuObj->pGPA = (PFN_vkGPA)nextGPA;
         nextGpuObj->baseObject = baseObj;
         nextGpuObj->nextObject = nextObj;
-        nextObj = (VkObject) nextGpuObj;
+        nextObj = (void*) nextGpuObj;
 
         char funcStr[256];
         snprintf(funcStr, 256, "%sGetDeviceProcAddr", layer_prop->info.layerName);
@@ -2261,7 +2261,7 @@ static uint32_t loader_activate_device_layers(
     }
 
     loader_init_device_dispatch_table(&dev->loader_dispatch, nextGPA,
-            (VkPhysicalDevice) nextObj, (VkPhysicalDevice) baseObj);
+            (VkDevice) nextObj, (VkDevice) baseObj);
     free(wrappedGpus);
 
     return dev->activated_layer_list.count;
@@ -2824,7 +2824,7 @@ VkResult loader_CreateDevice(
     }
     PFN_vkGetDeviceProcAddr get_proc_addr = icd->GetDeviceProcAddr;
     loader_init_device_dispatch_table(&dev->loader_dispatch, get_proc_addr,
-                                      icd->gpus[gpu_index], icd->gpus[gpu_index]);
+                                      (VkDevice) icd->gpus[gpu_index], (VkDevice) icd->gpus[gpu_index]);
 
     dev->loader_dispatch.CreateDevice = scratch_vkCreateDevice;
     loader_init_dispatch(*pDevice, &dev->loader_dispatch);
diff --git a/loader/loader.h b/loader/loader.h
index 24c0d3ba..d5395d6e 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -298,22 +298,22 @@ static inline struct loader_instance *loader_instance(VkInstance instance) {
     return (struct loader_instance *) instance;
 }
 
-static inline void loader_set_dispatch(VkObject obj, const void *data)
+static inline void loader_set_dispatch(void* obj, const void *data)
 {
     *((const void **) obj) = data;
 }
 
-static inline VkLayerDispatchTable *loader_get_dispatch(const VkObject obj)
+static inline VkLayerDispatchTable *loader_get_dispatch(const void* obj)
 {
     return *((VkLayerDispatchTable **) obj);
 }
 
-static inline VkLayerInstanceDispatchTable *loader_get_instance_dispatch(const VkObject obj)
+static inline VkLayerInstanceDispatchTable *loader_get_instance_dispatch(const void* obj)
 {
     return *((VkLayerInstanceDispatchTable **) obj);
 }
 
-static inline void loader_init_dispatch(VkObject obj, const void *data)
+static inline void loader_init_dispatch(void* obj, const void *data)
 {
 #ifdef DEBUG
     assert(valid_loader_magic_value(obj) &&
diff --git a/loader/table_ops.h b/loader/table_ops.h
index d6ddbfce..df8c2b4a 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -49,34 +49,46 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->UnmapMemory = (PFN_vkUnmapMemory) gpa(dev, "vkUnmapMemory");
     table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) gpa(dev, "vkFlushMappedMemoryRanges");
     table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) gpa(dev, "vkInvalidateMappedMemoryRanges");
-    table->DestroyObject = (PFN_vkDestroyObject) gpa(dev, "vkDestroyObject");
-    table->GetObjectMemoryRequirements = (PFN_vkGetObjectMemoryRequirements) gpa(dev, "vkGetObjectMemoryRequirements");
-    table->BindObjectMemory = (PFN_vkBindObjectMemory) gpa(dev, "vkBindObjectMemory");
+    table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements) gpa(dev, "vkGetBufferMemoryRequirements");
+    table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements) gpa(dev, "vkGetImageMemoryRequirements");
+    table->BindBufferMemory = (PFN_vkBindBufferMemory) gpa(dev, "vkBindBufferMemory");
+    table->BindImageMemory = (PFN_vkBindImageMemory) gpa(dev, "vkBindImageMemory");
     table->QueueBindSparseBufferMemory = (PFN_vkQueueBindSparseBufferMemory) gpa(dev, "vkQueueBindSparseBufferMemory");
     table->QueueBindSparseImageMemory = (PFN_vkQueueBindSparseImageMemory) gpa(dev, "vkQueueBindSparseImageMemory");
     table->QueueBindSparseImageOpaqueMemory = (PFN_vkQueueBindSparseImageOpaqueMemory) gpa(dev, "vkQueueBindSparseImageOpaqueMemory");
     table->GetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) gpa(dev, "vkGetImageSparseMemoryRequirements");
     table->CreateFence = (PFN_vkCreateFence) gpa(dev, "vkCreateFence");
+    table->DestroyFence = (PFN_vkDestroyFence) gpa(dev, "vkDestroyFence");
     table->ResetFences = (PFN_vkResetFences) gpa(dev, "vkResetFences");
     table->GetFenceStatus = (PFN_vkGetFenceStatus) gpa(dev, "vkGetFenceStatus");
     table->WaitForFences = (PFN_vkWaitForFences) gpa(dev, "vkWaitForFences");
     table->CreateSemaphore = (PFN_vkCreateSemaphore) gpa(dev, "vkCreateSemaphore");
+    table->DestroySemaphore = (PFN_vkDestroySemaphore) gpa(dev, "vkDestroySemaphore");
     table->QueueSignalSemaphore = (PFN_vkQueueSignalSemaphore) gpa(dev, "vkQueueSignalSemaphore");
     table->QueueWaitSemaphore = (PFN_vkQueueWaitSemaphore) gpa(dev, "vkQueueWaitSemaphore");
     table->CreateEvent = (PFN_vkCreateEvent) gpa(dev, "vkCreateEvent");
+    table->DestroyEvent = (PFN_vkDestroyEvent) gpa(dev, "vkDestroyEvent");
     table->GetEventStatus = (PFN_vkGetEventStatus) gpa(dev, "vkGetEventStatus");
     table->SetEvent = (PFN_vkSetEvent) gpa(dev, "vkSetEvent");
     table->ResetEvent = (PFN_vkResetEvent) gpa(dev, "vkResetEvent");
     table->CreateQueryPool = (PFN_vkCreateQueryPool) gpa(dev, "vkCreateQueryPool");
+    table->DestroyQueryPool = (PFN_vkDestroyQueryPool) gpa(dev, "vkDestroyQueryPool");
     table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults) gpa(dev, "vkGetQueryPoolResults");
     table->CreateBuffer = (PFN_vkCreateBuffer) gpa(dev, "vkCreateBuffer");
+    table->DestroyBuffer = (PFN_vkDestroyBuffer) gpa(dev, "vkDestroyBuffer");
     table->CreateBufferView = (PFN_vkCreateBufferView) gpa(dev, "vkCreateBufferView");
+    table->DestroyBufferView = (PFN_vkDestroyBufferView) gpa(dev, "vkDestroyBufferView");
     table->CreateImage = (PFN_vkCreateImage) gpa(dev, "vkCreateImage");
+    table->DestroyImage = (PFN_vkDestroyImage) gpa(dev, "vkDestroyImage");
     table->GetImageSubresourceLayout = (PFN_vkGetImageSubresourceLayout) gpa(dev, "vkGetImageSubresourceLayout");
     table->CreateImageView = (PFN_vkCreateImageView) gpa(dev, "vkCreateImageView");
+    table->DestroyImageView = (PFN_vkDestroyImageView) gpa(dev, "vkDestroyImageView");
     table->CreateAttachmentView = (PFN_vkCreateAttachmentView) gpa(dev, "vkCreateAttachmentView");
+    table->DestroyAttachmentView = (PFN_vkDestroyAttachmentView) gpa(dev, "vkDestroyAttachmentView");
     table->CreateShaderModule = (PFN_vkCreateShaderModule) gpa(dev, "vkCreateShaderModule");
+    table->DestroyShaderModule = (PFN_vkDestroyShaderModule) gpa(dev, "vkDestroyShaderModule");
     table->CreateShader = (PFN_vkCreateShader) gpa(dev, "vkCreateShader");
+    table->DestroyShader = (PFN_vkDestroyShader) gpa(dev, "vkDestroyShader");
     table->CreatePipelineCache = (PFN_vkCreatePipelineCache) gpa(dev, "vkCreatePipelineCache");
     table->DestroyPipelineCache = (PFN_vkDestroyPipelineCache) gpa(dev, "vkDestroyPipelineCache");
     table->GetPipelineCacheSize = (PFN_vkGetPipelineCacheSize) gpa(dev, "vkGetPipelineCacheSize");
@@ -84,23 +96,36 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->MergePipelineCaches = (PFN_vkMergePipelineCaches) gpa(dev, "vkMergePipelineCaches");
     table->CreateGraphicsPipelines = (PFN_vkCreateGraphicsPipelines) gpa(dev, "vkCreateGraphicsPipelines");
     table->CreateComputePipelines = (PFN_vkCreateComputePipelines) gpa(dev, "vkCreateComputePipelines");
+    table->DestroyPipeline = (PFN_vkDestroyPipeline) gpa(dev, "vkDestroyPipeline");
     table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout) gpa(dev, "vkCreatePipelineLayout");
+    table->DestroyPipelineLayout = (PFN_vkDestroyPipelineLayout) gpa(dev, "vkDestroyPipelineLayout");
     table->CreateSampler = (PFN_vkCreateSampler) gpa(dev, "vkCreateSampler");
+    table->DestroySampler = (PFN_vkDestroySampler) gpa(dev, "vkDestroySampler");
     table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) gpa(dev, "vkCreateDescriptorSetLayout");
+    table->DestroyDescriptorSetLayout = (PFN_vkDestroyDescriptorSetLayout) gpa(dev, "vkDestroyDescriptorSetLayout");
     table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool) gpa(dev, "vkCreateDescriptorPool");
+    table->DestroyDescriptorPool = (PFN_vkDestroyDescriptorPool) gpa(dev, "vkDestroyDescriptorPool");
     table->ResetDescriptorPool = (PFN_vkResetDescriptorPool) gpa(dev, "vkResetDescriptorPool");
     table->AllocDescriptorSets = (PFN_vkAllocDescriptorSets) gpa(dev, "vkAllocDescriptorSets");
     table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(dev, "vkUpdateDescriptorSets");
     table->CreateDynamicViewportState = (PFN_vkCreateDynamicViewportState) gpa(dev, "vkCreateDynamicViewportState");
+    table->DestroyDynamicViewportState = (PFN_vkDestroyDynamicViewportState) gpa(dev, "vkDestroyDynamicViewportState");
     table->CreateDynamicRasterState = (PFN_vkCreateDynamicRasterState) gpa(dev, "vkCreateDynamicRasterState");
+    table->DestroyDynamicRasterState = (PFN_vkDestroyDynamicRasterState) gpa(dev, "vkDestroyDynamicRasterState");
     table->CreateDynamicColorBlendState = (PFN_vkCreateDynamicColorBlendState) gpa(dev, "vkCreateDynamicColorBlendState");
+    table->DestroyDynamicColorBlendState = (PFN_vkDestroyDynamicColorBlendState) gpa(dev, "vkDestroyDynamicColorBlendState");
     table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(dev, "vkCreateDynamicDepthStencilState");
+    table->DestroyDynamicDepthStencilState = (PFN_vkDestroyDynamicDepthStencilState) gpa(dev, "vkDestroyDynamicDepthStencilState");
     table->CreateCommandBuffer = (PFN_vkCreateCommandBuffer) gpa(dev, "vkCreateCommandBuffer");
+    table->DestroyCommandBuffer = (PFN_vkDestroyCommandBuffer) gpa(dev, "vkDestroyCommandBuffer");
     table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(dev, "vkBeginCommandBuffer");
     table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(dev, "vkEndCommandBuffer");
     table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(dev, "vkResetCommandBuffer");
     table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(dev, "vkCmdBindPipeline");
-    table->CmdBindDynamicStateObject = (PFN_vkCmdBindDynamicStateObject) gpa(dev, "vkCmdBindDynamicStateObject");
+    table->CmdBindDynamicViewportState = (PFN_vkCmdBindDynamicViewportState) gpa(dev, "vkCmdBindDynamicViewportState");
+    table->CmdBindDynamicRasterState = (PFN_vkCmdBindDynamicRasterState) gpa(dev, "vkCmdBindDynamicRasterState");
+    table->CmdBindDynamicColorBlendState = (PFN_vkCmdBindDynamicColorBlendState) gpa(dev, "vkCmdBindDynamicColorBlendState");
+    table->CmdBindDynamicDepthStencilState = (PFN_vkCmdBindDynamicDepthStencilState) gpa(dev, "vkCmdBindDynamicDepthStencilState");
     table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(dev, "vkCmdBindDescriptorSets");
     table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) gpa(dev, "vkCmdBindVertexBuffers");
     table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) gpa(dev, "vkCmdBindIndexBuffer");
@@ -132,7 +157,9 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) gpa(dev, "vkCmdWriteTimestamp");
     table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) gpa(dev, "vkCmdCopyQueryPoolResults");
     table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(dev, "vkCreateFramebuffer");
+    table->DestroyFramebuffer = (PFN_vkDestroyFramebuffer) gpa(dev, "vkDestroyFramebuffer");
     table->CreateRenderPass = (PFN_vkCreateRenderPass) gpa(dev, "vkCreateRenderPass");
+    table->DestroyRenderPass = (PFN_vkDestroyRenderPass) gpa(dev, "vkDestroyRenderPass");
     table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) gpa(dev, "vkCmdBeginRenderPass");
     table->CmdNextSubpass = (PFN_vkCmdNextSubpass) gpa(dev, "vkCmdNextSubpass");
     table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass) gpa(dev, "vkCmdEndRenderPass");
@@ -180,12 +207,14 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->FlushMappedMemoryRanges;
     if (!strcmp(name, "InvalidateMappedMemoryRanges"))
         return (void *) table->InvalidateMappedMemoryRanges;
-    if (!strcmp(name, "DestroyObject"))
-        return (void *) table->DestroyObject;
-    if (!strcmp(name, "GetObjectMemoryRequirements"))
-        return (void *) table->GetObjectMemoryRequirements;
-    if (!strcmp(name, "BindObjectMemory"))
-        return (void *) table->BindObjectMemory;
+    if (!strcmp(name, "GetBufferMemoryRequirements"))
+        return (void *) table->GetBufferMemoryRequirements;
+    if (!strcmp(name, "GetImageMemoryRequirements"))
+        return (void *) table->GetImageMemoryRequirements;
+    if (!strcmp(name, "BindBufferMemory"))
+        return (void *) table->BindBufferMemory;
+    if (!strcmp(name, "BindImageMemory"))
+        return (void *) table->BindImageMemory;
     if (!strcmp(name, "QueueBindSparseBufferMemory"))
         return (void *) table->QueueBindSparseBufferMemory;
     if (!strcmp(name, "QueueBindSparseImageMemory"))
@@ -196,6 +225,8 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->GetImageSparseMemoryRequirements;
     if (!strcmp(name, "CreateFence"))
         return (void *) table->CreateFence;
+    if (!strcmp(name, "DestroyFence"))
+        return (void *) table->DestroyFence;
     if (!strcmp(name, "ResetFences"))
         return (void *) table->ResetFences;
     if (!strcmp(name, "GetFenceStatus"))
@@ -204,12 +235,16 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->WaitForFences;
     if (!strcmp(name, "CreateSemaphore"))
         return (void *) table->CreateSemaphore;
+    if (!strcmp(name, "DestroySemaphore"))
+        return (void *) table->DestroySemaphore;
     if (!strcmp(name, "QueueSignalSemaphore"))
         return (void *) table->QueueSignalSemaphore;
     if (!strcmp(name, "QueueWaitSemaphore"))
         return (void *) table->QueueWaitSemaphore;
     if (!strcmp(name, "CreateEvent"))
         return (void *) table->CreateEvent;
+    if (!strcmp(name, "DestroyEvent"))
+        return (void *) table->DestroyEvent;
     if (!strcmp(name, "GetEventStatus"))
         return (void *) table->GetEventStatus;
     if (!strcmp(name, "SetEvent"))
@@ -218,24 +253,40 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->ResetEvent;
     if (!strcmp(name, "CreateQueryPool"))
         return (void *) table->CreateQueryPool;
+    if (!strcmp(name, "DestroyQueryPool"))
+        return (void *) table->DestroyQueryPool;
     if (!strcmp(name, "GetQueryPoolResults"))
         return (void *) table->GetQueryPoolResults;
     if (!strcmp(name, "CreateBuffer"))
         return (void *) table->CreateBuffer;
+    if (!strcmp(name, "DestroyBuffer"))
+        return (void *) table->DestroyBuffer;
     if (!strcmp(name, "CreateBufferView"))
         return (void *) table->CreateBufferView;
+    if (!strcmp(name, "DestroyBufferView"))
+        return (void *) table->DestroyBufferView;
     if (!strcmp(name, "CreateImage"))
         return (void *) table->CreateImage;
+    if (!strcmp(name, "DestroyImage"))
+        return (void *) table->DestroyImage;
     if (!strcmp(name, "GetImageSubresourceLayout"))
         return (void *) table->GetImageSubresourceLayout;
     if (!strcmp(name, "CreateImageView"))
         return (void *) table->CreateImageView;
+    if (!strcmp(name, "DestroyImageView"))
+        return (void *) table->DestroyImageView;
     if (!strcmp(name, "CreateAttachmentView"))
         return (void *) table->CreateAttachmentView;
+    if (!strcmp(name, "DestroyAttachmentView"))
+        return (void *) table->DestroyAttachmentView;
     if (!strcmp(name, "CreateShaderModule"))
         return (void *) table->CreateShaderModule;
+    if (!strcmp(name, "DestroyShaderModule"))
+        return (void *) table->DestroyShaderModule;
     if (!strcmp(name, "CreateShader"))
         return (void *) table->CreateShader;
+    if (!strcmp(name, "DestroyShader"))
+        return (void *) table->DestroyShader;
     if (!strcmp(name, "CreatePipelineCache"))
         return (void*) vkCreatePipelineCache;
     if (!strcmp(name, "DestroyPipelineCache"))
@@ -250,14 +301,24 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void*) vkCreateGraphicsPipelines;
     if (!strcmp(name, "CreateComputePipelines"))
         return (void*) vkCreateComputePipelines;
+    if (!strcmp(name, "DestroyPipeline"))
+        return (void *) table->DestroyPipeline;
     if (!strcmp(name, "CreatePipelineLayout"))
         return (void *) table->CreatePipelineLayout;
+    if (!strcmp(name, "DestroyPipelineLayout"))
+        return (void *) table->DestroyPipelineLayout;
     if (!strcmp(name, "CreateSampler"))
         return (void *) table->CreateSampler;
+    if (!strcmp(name, "DestroySampler"))
+        return (void *) table->DestroySampler;
     if (!strcmp(name, "CreateDescriptorSetLayout"))
         return (void *) table->CreateDescriptorSetLayout;
+    if (!strcmp(name, "DestroyDescriptorSetLayout"))
+        return (void *) table->DestroyDescriptorSetLayout;
     if (!strcmp(name, "CreateDescriptorPool"))
         return (void *) table->CreateDescriptorPool;
+    if (!strcmp(name, "DestroyDescriptorPool"))
+        return (void *) table->DestroyDescriptorPool;
     if (!strcmp(name, "ResetDescriptorPool"))
         return (void *) table->ResetDescriptorPool;
     if (!strcmp(name, "AllocDescriptorSets"))
@@ -266,14 +327,24 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->UpdateDescriptorSets;
     if (!strcmp(name, "CreateDynamicViewportState"))
         return (void *) table->CreateDynamicViewportState;
+    if (!strcmp(name, "DestroyDynamicViewportState"))
+        return (void *) table->DestroyDynamicViewportState;
     if (!strcmp(name, "CreateDynamicRasterState"))
         return (void *) table->CreateDynamicRasterState;
+    if (!strcmp(name, "DestroyDynamicRasterState"))
+        return (void *) table->DestroyDynamicRasterState;
     if (!strcmp(name, "CreateDynamicColorBlendState"))
         return (void *) table->CreateDynamicColorBlendState;
+    if (!strcmp(name, "DestroyDynamicColorBlendState"))
+        return (void *) table->DestroyDynamicColorBlendState;
     if (!strcmp(name, "CreateDynamicDepthStencilState"))
         return (void *) table->CreateDynamicDepthStencilState;
+    if (!strcmp(name, "DestroyDynamicDepthStencilState"))
+        return (void *) table->DestroyDynamicDepthStencilState;
     if (!strcmp(name, "CreateCommandBuffer"))
         return (void *) table->CreateCommandBuffer;
+    if (!strcmp(name, "DestroyCommandBuffer"))
+        return (void *) table->DestroyCommandBuffer;
     if (!strcmp(name, "BeginCommandBuffer"))
         return (void *) table->BeginCommandBuffer;
     if (!strcmp(name, "EndCommandBuffer"))
@@ -282,8 +353,14 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->ResetCommandBuffer;
     if (!strcmp(name, "CmdBindPipeline"))
         return (void *) table->CmdBindPipeline;
-    if (!strcmp(name, "CmdBindDynamicStateObject"))
-        return (void *) table->CmdBindDynamicStateObject;
+    if (!strcmp(name, "CmdBindDynamicViewportState"))
+        return (void *) table->CmdBindDynamicViewportState;
+    if (!strcmp(name, "CmdBindDynamicRasterState"))
+        return (void *) table->CmdBindDynamicRasterState;
+    if (!strcmp(name, "CmdBindDynamicColorBlendState"))
+        return (void *) table->CmdBindDynamicColorBlendState;
+    if (!strcmp(name, "CmdBindDynamicDepthStencilState"))
+        return (void *) table->CmdBindDynamicDepthStencilState;
     if (!strcmp(name, "CmdBindDescriptorSets"))
         return (void *) table->CmdBindDescriptorSets;
     if (!strcmp(name, "CmdBindVertexBuffers"))
@@ -346,8 +423,12 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->CmdCopyQueryPoolResults;
     if (!strcmp(name, "CreateFramebuffer"))
         return (void *) table->CreateFramebuffer;
+    if (!strcmp(name, "DestroyFramebuffer"))
+        return (void *) table->DestroyFramebuffer;
     if (!strcmp(name, "CreateRenderPass"))
         return (void *) table->CreateRenderPass;
+    if (!strcmp(name, "DestroyRenderPass"))
+        return (void *) table->DestroyRenderPass;
     if (!strcmp(name, "CmdBeginRenderPass"))
         return (void *) table->CmdBeginRenderPass;
     if (!strcmp(name, "CmdNextSubpass"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index baa7bd1f..dbd134fd 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -420,31 +420,40 @@ LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uin
     return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
 }
 
-LOADER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object)
+LOADER_EXPORT VkResult VKAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->DestroyObject(device, objType, object);
+    return disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetObjectMemoryRequirements(VkDevice device, VkObjectType objType, VkObject object, VkMemoryRequirements* pMemoryRequirements)
+LOADER_EXPORT VkResult VKAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->GetObjectMemoryRequirements(device, objType, object, pMemoryRequirements);
+    return disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
-LOADER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize offset)
+LOADER_EXPORT VkResult VKAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->BindObjectMemory(device, objType, object, mem, offset);
+    return disp->BindBufferMemory(device, buffer, mem, offset);
+}
+
+LOADER_EXPORT VkResult VKAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->BindImageMemory(device, image, mem, offset);
 }
 
 LOADER_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
@@ -501,6 +510,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateI
     return disp->CreateFence(device, pCreateInfo, pFence);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyFence(VkDevice device, VkFence fence)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyFence(device, fence);
+}
+
 LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
 {
     const VkLayerDispatchTable *disp;
@@ -537,6 +555,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphor
     return disp->CreateSemaphore(device, pCreateInfo, pSemaphore);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroySemaphore(device, semaphore);
+}
+
 LOADER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore)
 {
     const VkLayerDispatchTable *disp;
@@ -564,6 +591,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateI
     return disp->CreateEvent(device, pCreateInfo, pEvent);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyEvent(device, event);
+}
+
 LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event)
 {
     const VkLayerDispatchTable *disp;
@@ -600,6 +636,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoo
     return disp->CreateQueryPool(device, pCreateInfo, pQueryPool);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyQueryPool(device, queryPool);
+}
+
 LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags)
 {
     const VkLayerDispatchTable *disp;
@@ -618,6 +663,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreat
     return disp->CreateBuffer(device, pCreateInfo, pBuffer);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyBuffer(device, buffer);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
 {
     const VkLayerDispatchTable *disp;
@@ -627,6 +681,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferV
     return disp->CreateBufferView(device, pCreateInfo, pView);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyBufferView(device, bufferView);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
 {
     const VkLayerDispatchTable *disp;
@@ -636,6 +699,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateI
     return disp->CreateImage(device, pCreateInfo, pImage);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyImage(VkDevice device, VkImage image)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyImage(device, image);
+}
+
 LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
 {
     const VkLayerDispatchTable *disp;
@@ -654,6 +726,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageVie
     return disp->CreateImageView(device, pCreateInfo, pView);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyImageView(device, imageView);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateAttachmentView(VkDevice device, const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView)
 {
     const VkLayerDispatchTable *disp;
@@ -663,6 +744,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateAttachmentView(VkDevice device, const VkAtt
     return disp->CreateAttachmentView(device, pCreateInfo, pView);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyAttachmentView(VkDevice device, VkAttachmentView attachmentView)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyAttachmentView(device, attachmentView);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader)
 {
     const VkLayerDispatchTable *disp;
@@ -672,6 +762,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShade
     return disp->CreateShaderModule(device, pCreateInfo, pShader);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyShaderModule(device, shaderModule);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
 {
     const VkLayerDispatchTable *disp;
@@ -681,6 +780,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreat
     return disp->CreateShader(device, pCreateInfo, pShader);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyShader(VkDevice device, VkShader shader)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyShader(device, shader);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache)
 {
     const VkLayerDispatchTable *disp;
@@ -744,6 +852,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelin
     return disp->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyPipeline(device, pipeline);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
 {
     const VkLayerDispatchTable *disp;
@@ -753,6 +870,15 @@ LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPip
     return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyPipelineLayout(device, pipelineLayout);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
 {
     const VkLayerDispatchTable *disp;
@@ -762,6 +888,16 @@ LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCre
     return disp->CreateSampler(device, pCreateInfo, pSampler);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroySampler(device, sampler);
+}
+
+
 LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
 {
     const VkLayerDispatchTable *disp;
@@ -771,6 +907,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const
     return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDescriptorSetLayout(device, descriptorSetLayout);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
 {
     const VkLayerDispatchTable *disp;
@@ -780,6 +925,16 @@ LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescripto
     return disp->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDescriptorPool(device, descriptorPool);
+}
+
+
 LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
 {
     const VkLayerDispatchTable *disp;
@@ -807,7 +962,7 @@ LOADER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t wr
     return disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState)
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState)
 {
     const VkLayerDispatchTable *disp;
 
@@ -816,7 +971,16 @@ LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const
     return disp->CreateDynamicViewportState(device, pCreateInfo, pState);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState)
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDynamicViewportState(device, dynamicViewportState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState)
 {
     const VkLayerDispatchTable *disp;
 
@@ -825,7 +989,16 @@ LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const V
     return disp->CreateDynamicRasterState(device, pCreateInfo, pState);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState)
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicRasterState(VkDevice device, VkDynamicRasterState dynamicRasterState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDynamicRasterState(device, dynamicRasterState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState)
 {
     const VkLayerDispatchTable *disp;
 
@@ -834,7 +1007,16 @@ LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, con
     return disp->CreateDynamicColorBlendState(device, pCreateInfo, pState);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState)
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicColorBlendState(VkDevice device, VkDynamicColorBlendState dynamicColorBlendState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDynamicColorBlendState(device, dynamicColorBlendState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState)
 {
     const VkLayerDispatchTable *disp;
 
@@ -843,6 +1025,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, c
     return disp->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyDynamicDepthStencilState(VkDevice device, VkDynamicDepthStencilState dynamicDepthStencilState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDynamicDepthStencilState(device, dynamicDepthStencilState);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
 {
     const VkLayerDispatchTable *disp;
@@ -858,6 +1049,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdB
     return res;
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdBuffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyCommandBuffer(device, cmdBuffer);
+}
+
 LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
 {
     const VkLayerDispatchTable *disp;
@@ -894,13 +1094,40 @@ LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBind
     disp->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state)
+LOADER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, VkDynamicViewportState state)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
+    disp->CmdBindDynamicViewportState(cmdBuffer, state);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindDynamicRasterState(VkCmdBuffer cmdBuffer, VkDynamicRasterState state)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindDynamicRasterState(cmdBuffer, state);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindDynamicColorBlendState(VkCmdBuffer cmdBuffer, VkDynamicColorBlendState state)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindDynamicColorBlendState(cmdBuffer, state);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthStencilState(VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState state)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindDynamicDepthStencilState(cmdBuffer, state);
 }
 
 LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
@@ -1182,6 +1409,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFrameb
     return disp->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyFramebuffer(device, framebuffer);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
 {
     const VkLayerDispatchTable *disp;
@@ -1191,6 +1427,15 @@ LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderP
     return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
 }
 
+LOADER_EXPORT VkResult VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyRenderPass(device, renderPass);
+}
+
 LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
 {
     const VkLayerDispatchTable *disp;