loader: Add missing entrypoints CmdPushConstants, GetRenderArea, GetPDImgFormat

Also fix several other missing entrypoints from dispatch table related functions.
Also reorder some of these functions to better match header list order so
can more easily spot missing entry points.

5 files changed, 207 insertions, 120 deletions

diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index 5373603e..e462a1d7 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -37,6 +37,14 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkDestroyInstance;
     if (!strcmp(name, "EnumeratePhysicalDevices"))
         return (void*) vkEnumeratePhysicalDevices;
+    if (!strcmp(name, "GetPhysicalDeviceFeatures"))
+        return (void*) vkGetPhysicalDeviceFeatures;
+    if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
+        return (void*) vkGetPhysicalDeviceFormatProperties;
+    if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties"))
+        return (void*) vkGetPhysicalDeviceImageFormatProperties;
+    if (!strcmp(name, "GetPhysicalDeviceLimits"))
+        return (void*) vkGetPhysicalDeviceLimits;
     if (!strcmp(name, "GetPhysicalDeviceProperties"))
         return (void*) vkGetPhysicalDeviceProperties;
     if (!strcmp(name, "GetPhysicalDeviceQueueCount"))
@@ -45,12 +53,6 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkGetPhysicalDeviceQueueProperties;
     if (!strcmp(name, "GetPhysicalDeviceMemoryProperties"))
         return (void*) vkGetPhysicalDeviceMemoryProperties;
-    if (!strcmp(name, "GetPhysicalDeviceFeatures"))
-        return (void*) vkGetPhysicalDeviceFeatures;
-    if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
-        return (void*) vkGetPhysicalDeviceFormatProperties;
-    if (!strcmp(name, "GetPhysicalDeviceLimits"))
-        return (void*) vkGetPhysicalDeviceLimits;
     if (!strcmp(name, "GetInstanceProcAddr"))
         return (void*) vkGetInstanceProcAddr;
     if (!strcmp(name, "GetDeviceProcAddr"))
@@ -67,8 +69,6 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkGetGlobalLayerProperties;
     if (!strcmp(name, "GetPhysicalDeviceLayerProperties"))
         return (void*) vkGetPhysicalDeviceLayerProperties;
-    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
-        return (void*) vkGetPhysicalDeviceSparseImageFormatProperties;
     if (!strcmp(name, "GetDeviceQueue"))
         return (void*) vkGetDeviceQueue;
     if (!strcmp(name, "QueueSubmit"))
@@ -89,22 +89,26 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkFlushMappedMemoryRanges;
     if (!strcmp(name, "InvalidateMappedMemoryRanges"))
         return (void*) vkInvalidateMappedMemoryRanges;
-    if (!strcmp(name, "GetImageMemoryRequirements"))
-        return (void*) vkGetImageMemoryRequirements;
-    if (!strcmp(name, "GetBufferMemoryRequirements"))
-        return (void*) vkGetBufferMemoryRequirements;
-    if (!strcmp(name, "BindImageMemory"))
-        return (void*) vkBindImageMemory;
+    if (!strcmp(name, "GetDeviceMemoryCommitment"))
+        return (void *) vkGetDeviceMemoryCommitment;
     if (!strcmp(name, "BindBufferMemory"))
         return (void*) vkBindBufferMemory;
+    if (!strcmp(name, "BindImageMemory"))
+        return (void*) vkBindImageMemory;
+    if (!strcmp(name, "GetBufferMemoryRequirements"))
+        return (void*) vkGetBufferMemoryRequirements;
+    if (!strcmp(name, "GetImageMemoryRequirements"))
+        return (void*) vkGetImageMemoryRequirements;
+    if (!strcmp(name, "GetImageSparseMemoryRequirements"))
+        return (void*) vkGetImageSparseMemoryRequirements;
+    if (!strcmp(name, "GetPhysicalDeviceSparseImageFormatProperties"))
+        return (void*) vkGetPhysicalDeviceSparseImageFormatProperties;
     if (!strcmp(name, "QueueBindSparseBufferMemory"))
         return (void*) vkQueueBindSparseBufferMemory;
-    if (!strcmp(name, "QueueBindSparseImageMemory"))
-        return (void*) vkQueueBindSparseImageMemory;
     if (!strcmp(name, "QueueBindSparseImageOpaqueMemory"))
         return (void*) vkQueueBindSparseImageOpaqueMemory;
-    if (!strcmp(name, "GetImageSparseMemoryRequirements"))
-        return (void*) vkGetImageSparseMemoryRequirements;
+    if (!strcmp(name, "QueueBindSparseImageMemory"))
+        return (void*) vkQueueBindSparseImageMemory;
     if (!strcmp(name, "CreateFence"))
         return (void*) vkCreateFence;
     if (!strcmp(name, "DestroyFence"))
@@ -225,6 +229,16 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkCreateDynamicDepthStencilState;
     if (!strcmp(name, "DestroyDynamicDepthStencilState"))
         return (void*) vkDestroyDynamicDepthStencilState;
+    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, "GetRenderAreaGranularity"))
+        return (void*) vkGetRenderAreaGranularity;
     if (!strcmp(name, "CreateCommandPool"))
         return (void*) vkCreateCommandPool;
     if (!strcmp(name, "DestroyCommandPool"))
@@ -253,10 +267,10 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkCmdBindDynamicDepthStencilState;
     if (!strcmp(name, "CmdBindDescriptorSets"))
         return (void*) vkCmdBindDescriptorSets;
-    if (!strcmp(name, "CmdBindVertexBuffers"))
-        return (void*) vkCmdBindVertexBuffers;
     if (!strcmp(name, "CmdBindIndexBuffer"))
         return (void*) vkCmdBindIndexBuffer;
+    if (!strcmp(name, "CmdBindVertexBuffers"))
+        return (void*) vkCmdBindVertexBuffers;
     if (!strcmp(name, "CmdDraw"))
         return (void*) vkCmdDraw;
     if (!strcmp(name, "CmdDrawIndexed"))
@@ -311,21 +325,16 @@ static inline void* globalGetProcAddr(const char *name)
         return (void*) vkCmdWriteTimestamp;
     if (!strcmp(name, "CmdCopyQueryPoolResults"))
         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, "CmdPushConstants"))
+        return (void*) vkCmdPushConstants;
     if (!strcmp(name, "CmdBeginRenderPass"))
         return (void*) vkCmdBeginRenderPass;
     if (!strcmp(name, "CmdNextSubpass"))
         return (void*) vkCmdNextSubpass;
     if (!strcmp(name, "CmdEndRenderPass"))
         return (void*) vkCmdEndRenderPass;
-
+    if (!strcmp(name, "CmdExecuteCommands"))
+        return (void*) vkCmdExecuteCommands;
     return NULL;
 }
 
@@ -349,6 +358,8 @@ static inline void *loader_non_passthrough_gpa(const char *name)
         return (void*) vkGetPhysicalDeviceFeatures;
     if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
         return (void*) vkGetPhysicalDeviceFormatProperties;
+    if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties"))
+        return (void*) vkGetPhysicalDeviceImageFormatProperties;
     if (!strcmp(name, "GetPhysicalDeviceLimits"))
         return (void*) vkGetPhysicalDeviceLimits;
     if (!strcmp(name, "GetPhysicalDeviceQueueCount"))
@@ -369,6 +380,8 @@ static inline void *loader_non_passthrough_gpa(const char *name)
         return (void*) vkCreateDevice;
     if (!strcmp(name, "GetPhysicalDeviceExtensionProperties"))
         return (void*) vkGetPhysicalDeviceExtensionProperties;
+    if (!strcmp(name, "GetPhysicalDeviceLayerProperties"))
+        return (void*) vkGetPhysicalDeviceLayerProperties;
     if (!strcmp(name, "GetDeviceQueue"))
         return (void*) vkGetDeviceQueue;
     if (!strcmp(name, "CreateCommandBuffer"))
diff --git a/loader/loader.c b/loader/loader.c
index 9ea9a376..d10c4599 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -92,6 +92,7 @@ const VkLayerInstanceDispatchTable instance_disp = {
     .EnumeratePhysicalDevices = loader_EnumeratePhysicalDevices,
     .GetPhysicalDeviceFeatures = loader_GetPhysicalDeviceFeatures,
     .GetPhysicalDeviceFormatProperties = loader_GetPhysicalDeviceFormatProperties,
+    .GetPhysicalDeviceImageFormatProperties = loader_GetPhysicalDeviceImageFormatProperties,
     .GetPhysicalDeviceLimits = loader_GetPhysicalDeviceLimits,
     .GetPhysicalDeviceProperties = loader_GetPhysicalDeviceProperties,
     .GetPhysicalDeviceQueueCount = loader_GetPhysicalDeviceQueueCount,
@@ -958,6 +959,7 @@ static bool loader_icd_init_entrys(struct loader_icd *icd,
     LOOKUP_GIPA(EnumeratePhysicalDevices, true);
     LOOKUP_GIPA(GetPhysicalDeviceFeatures, true);
     LOOKUP_GIPA(GetPhysicalDeviceFormatProperties, true);
+    LOOKUP_GIPA(GetPhysicalDeviceImageFormatProperties, true);
     LOOKUP_GIPA(GetPhysicalDeviceLimits, true);
     LOOKUP_GIPA(CreateDevice, true);
     LOOKUP_GIPA(GetPhysicalDeviceProperties, true);
@@ -2632,6 +2634,25 @@ VkResult VKAPI loader_GetPhysicalDeviceFormatProperties(
     return res;
 }
 
+VkResult VKAPI loader_GetPhysicalDeviceImageFormatProperties(
+        VkPhysicalDevice                        physicalDevice,
+        VkFormat                                format,
+        VkImageType                             type,
+        VkImageTiling                           tiling,
+        VkImageUsageFlags                       usage,
+        VkImageFormatProperties*                pImageFormatProperties)
+{
+    uint32_t gpu_index;
+    struct loader_icd *icd = loader_get_icd(physicalDevice, &gpu_index);
+    VkResult res = VK_ERROR_INITIALIZATION_FAILED;
+
+    if (icd->GetPhysicalDeviceImageFormatProperties)
+        res = icd->GetPhysicalDeviceImageFormatProperties(physicalDevice, format,
+                                type, tiling, usage, pImageFormatProperties);
+
+    return res;
+}
+
 VkResult VKAPI loader_GetPhysicalDeviceLimits(
         VkPhysicalDevice                        physicalDevice,
         VkPhysicalDeviceLimits*                 pLimits)
diff --git a/loader/loader.h b/loader/loader.h
index bbc1a1ee..a4a9fd25 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -145,6 +145,7 @@ struct loader_icd {
     PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
     PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
     PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
+    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
     PFN_vkGetPhysicalDeviceLimits GetPhysicalDeviceLimits;
     PFN_vkCreateDevice CreateDevice;
     PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
@@ -359,6 +360,14 @@ VkResult VKAPI loader_GetPhysicalDeviceFormatProperties(
         VkFormat                                format,
         VkFormatProperties*                     pFormatInfo);
 
+VkResult VKAPI loader_GetPhysicalDeviceImageFormatProperties(
+        VkPhysicalDevice                        physicalDevice,
+        VkFormat                                format,
+        VkImageType                             type,
+        VkImageTiling                           tiling,
+        VkImageUsageFlags                       usage,
+        VkImageFormatProperties*                pImageFormatProperties);
+
 VkResult VKAPI loader_GetPhysicalDeviceLimits(
         VkPhysicalDevice                        physicalDevice,
         VkPhysicalDeviceLimits*                 pLimits);
diff --git a/loader/table_ops.h b/loader/table_ops.h
index de75eb2a..5a2e615e 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -50,6 +50,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) gpa(dev, "vkFlushMappedMemoryRanges");
     table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) gpa(dev, "vkInvalidateMappedMemoryRanges");
     table->GetDeviceMemoryCommitment = (PFN_vkGetDeviceMemoryCommitment) gpa(dev, "vkGetDeviceMemoryCommitment");
+    table->GetImageSparseMemoryRequirements = (PFN_vkGetImageSparseMemoryRequirements) gpa(dev, "vkGetImageSparseMemoryRequirements");
     table->GetBufferMemoryRequirements = (PFN_vkGetBufferMemoryRequirements) gpa(dev, "vkGetBufferMemoryRequirements");
     table->GetImageMemoryRequirements = (PFN_vkGetImageMemoryRequirements) gpa(dev, "vkGetImageMemoryRequirements");
     table->BindBufferMemory = (PFN_vkBindBufferMemory) gpa(dev, "vkBindBufferMemory");
@@ -57,7 +58,6 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     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");
@@ -118,6 +118,11 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->DestroyDynamicColorBlendState = (PFN_vkDestroyDynamicColorBlendState) gpa(dev, "vkDestroyDynamicColorBlendState");
     table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(dev, "vkCreateDynamicDepthStencilState");
     table->DestroyDynamicDepthStencilState = (PFN_vkDestroyDynamicDepthStencilState) gpa(dev, "vkDestroyDynamicDepthStencilState");
+    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->GetRenderAreaGranularity = (PFN_vkGetRenderAreaGranularity) gpa(dev, "vkGetRenderAreaGranularity");
     table->CreateCommandPool = (PFN_vkCreateCommandPool) gpa(dev, "vkCreateCommandPool");
     table->DestroyCommandPool = (PFN_vkDestroyCommandPool) gpa(dev, "vkDestroyCommandPool");
     table->ResetCommandPool = (PFN_vkResetCommandPool) gpa(dev, "vkResetCommandPool");
@@ -161,10 +166,7 @@ static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table
     table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool) gpa(dev, "vkCmdResetQueryPool");
     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->CmdPushConstants = (PFN_vkCmdPushConstants) gpa(dev, "vkCmdPushConstants");
     table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) gpa(dev, "vkCmdBeginRenderPass");
     table->CmdNextSubpass = (PFN_vkCmdNextSubpass) gpa(dev, "vkCmdNextSubpass");
     table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass) gpa(dev, "vkCmdEndRenderPass");
@@ -214,6 +216,8 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->InvalidateMappedMemoryRanges;
     if (!strcmp(name, "GetDeviceMemoryCommitment"))
         return (void *) table->GetDeviceMemoryCommitment;
+    if (!strcmp(name, "GetImageSparseMemoryRequirements"))
+        return (void *) table->GetImageSparseMemoryRequirements;
     if (!strcmp(name, "GetBufferMemoryRequirements"))
         return (void *) table->GetBufferMemoryRequirements;
     if (!strcmp(name, "GetImageMemoryRequirements"))
@@ -228,8 +232,6 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->QueueBindSparseImageMemory;
     if (!strcmp(name, "QueueBindSparseImageOpaqueMemory"))
         return (void *) table->QueueBindSparseImageOpaqueMemory;
-    if (!strcmp(name, "GetImageSparseMemoryRequirements"))
-        return (void *) table->GetImageSparseMemoryRequirements;
     if (!strcmp(name, "CreateFence"))
         return (void *) table->CreateFence;
     if (!strcmp(name, "DestroyFence"))
@@ -350,6 +352,16 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->CreateDynamicDepthStencilState;
     if (!strcmp(name, "DestroyDynamicDepthStencilState"))
         return (void *) table->DestroyDynamicDepthStencilState;
+    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, "GetRenderAreaGranularity"))
+        return (void *) table->GetRenderAreaGranularity;
     if (!strcmp(name, "CreateCommandPool"))
         return (void *) table->CreateCommandPool;
     if (!strcmp(name, "DestroyCommandPool"))
@@ -436,20 +448,16 @@ static inline void *loader_lookup_device_dispatch_table(
         return (void *) table->CmdWriteTimestamp;
     if (!strcmp(name, "CmdCopyQueryPoolResults"))
         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, "CmdPushConstants"))
+        return (void *) table->CmdPushConstants;
     if (!strcmp(name, "CmdBeginRenderPass"))
         return (void *) table->CmdBeginRenderPass;
     if (!strcmp(name, "CmdNextSubpass"))
         return (void *) table->CmdNextSubpass;
     if (!strcmp(name, "CmdEndRenderPass"))
         return (void *) table->CmdEndRenderPass;
+    if (!strcmp(name, "CmdExecuteCommands"))
+        return (void *) table->CmdExecuteCommands;
 
     return NULL;
 }
@@ -467,15 +475,16 @@ static inline void loader_init_instance_core_dispatch_table(VkLayerInstanceDispa
     table->DestroyInstance = (PFN_vkDestroyInstance) gpa(inst, "vkDestroyInstance");
     table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) gpa(inst, "vkEnumeratePhysicalDevices");
     table->GetPhysicalDeviceFeatures = (PFN_vkGetPhysicalDeviceFeatures) gpa(inst, "vkGetPhysicalDeviceFeatures");
+    table->GetPhysicalDeviceImageFormatProperties = (PFN_vkGetPhysicalDeviceImageFormatProperties) gpa(inst, "vkGetPhysicalDeviceImageFormatProperties");
     table->GetPhysicalDeviceFormatProperties = (PFN_vkGetPhysicalDeviceFormatProperties) gpa(inst, "vkGetPhysicalDeviceFormatProperties");
     table->GetPhysicalDeviceLimits = (PFN_vkGetPhysicalDeviceLimits) gpa(inst, "vkGetPhysicalDeviceLimits");
+    table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties");
     table->GetPhysicalDeviceProperties = (PFN_vkGetPhysicalDeviceProperties) gpa(inst, "vkGetPhysicalDeviceProperties");
     table->GetPhysicalDeviceQueueCount = (PFN_vkGetPhysicalDeviceQueueCount) gpa(inst, "vkGetPhysicalDeviceQueueCount");
     table->GetPhysicalDeviceQueueProperties = (PFN_vkGetPhysicalDeviceQueueProperties) gpa(inst, "vkGetPhysicalDeviceQueueProperties");
     table->GetPhysicalDeviceMemoryProperties = (PFN_vkGetPhysicalDeviceMemoryProperties) gpa(inst, "vkGetPhysicalDeviceMemoryProperties");
     table->GetPhysicalDeviceExtensionProperties = (PFN_vkGetPhysicalDeviceExtensionProperties) gpa(inst, "vkGetPhysicalDeviceExtensionProperties");
     table->GetPhysicalDeviceLayerProperties = (PFN_vkGetPhysicalDeviceLayerProperties) gpa(inst, "vkGetPhysicalDeviceLayerProperties");
-    table->GetPhysicalDeviceSparseImageFormatProperties = (PFN_vkGetPhysicalDeviceSparseImageFormatProperties) gpa(inst, "vkGetPhysicalDeviceSparseImageFormatProperties");
 }
 
 static inline void loader_init_instance_extension_dispatch_table(
@@ -503,6 +512,8 @@ static inline void *loader_lookup_instance_dispatch_table(
         return (void *) table->EnumeratePhysicalDevices;
     if (!strcmp(name, "GetPhysicalDeviceFeatures"))
         return (void *) table->GetPhysicalDeviceFeatures;
+    if (!strcmp(name, "GetPhysicalDeviceImageFormatProperties"))
+        return (void *) table->GetPhysicalDeviceImageFormatProperties;
     if (!strcmp(name, "GetPhysicalDeviceFormatProperties"))
         return (void *) table->GetPhysicalDeviceFormatProperties;
     if (!strcmp(name, "GetPhysicalDeviceLimits"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 114f0363..9bf6b70b 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -172,89 +172,104 @@ LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
     return res;
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
+
+
+
+
+
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(
                                             VkPhysicalDevice gpu,
-                                            VkPhysicalDeviceProperties* pProperties)
+                                            VkPhysicalDeviceFeatures *pFeatures)
 {
     const VkLayerInstanceDispatchTable *disp;
     VkResult res;
 
     disp = loader_get_instance_dispatch(gpu);
-    res = disp->GetPhysicalDeviceProperties(gpu, pProperties);
+    res = disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
     return res;
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueCount(
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
                                             VkPhysicalDevice gpu,
-                                            uint32_t* pCount)
+                                            VkFormat format,
+                                            VkFormatProperties *pFormatInfo)
 {
-   const VkLayerInstanceDispatchTable *disp;
-   VkResult res;
+    const VkLayerInstanceDispatchTable *disp;
+    VkResult res;
 
-   disp = loader_get_instance_dispatch(gpu);
-   res = disp->GetPhysicalDeviceQueueCount(gpu, pCount);
-   return res;
+    disp = loader_get_instance_dispatch(gpu);
+    res = disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
+    return res;
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueProperties(
-                                            VkPhysicalDevice gpu,
-                                            uint32_t count,
-                                            VkPhysicalDeviceQueueProperties* pQueueProperties)
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties)
 {
     const VkLayerInstanceDispatchTable *disp;
     VkResult res;
 
-    disp = loader_get_instance_dispatch(gpu);
-    res = disp->GetPhysicalDeviceQueueProperties(gpu, count, pQueueProperties);
+    disp = loader_get_instance_dispatch(physicalDevice);
+    res = disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties);
     return res;
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLimits(
                                             VkPhysicalDevice gpu,
-                                            VkPhysicalDeviceMemoryProperties* pMemoryProperties)
+                                            VkPhysicalDeviceLimits *pLimits)
 {
     const VkLayerInstanceDispatchTable *disp;
     VkResult res;
 
     disp = loader_get_instance_dispatch(gpu);
-    res = disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
+    res = disp->GetPhysicalDeviceLimits(gpu, pLimits);
     return res;
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
                                             VkPhysicalDevice gpu,
-                                            VkPhysicalDeviceFeatures *pFeatures)
+                                            VkPhysicalDeviceProperties* pProperties)
 {
     const VkLayerInstanceDispatchTable *disp;
     VkResult res;
 
     disp = loader_get_instance_dispatch(gpu);
-    res = disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
+    res = disp->GetPhysicalDeviceProperties(gpu, pProperties);
     return res;
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueCount(
                                             VkPhysicalDevice gpu,
-                                            VkFormat format,
-                                            VkFormatProperties *pFormatInfo)
+                                            uint32_t* pCount)
+{
+   const VkLayerInstanceDispatchTable *disp;
+   VkResult res;
+
+   disp = loader_get_instance_dispatch(gpu);
+   res = disp->GetPhysicalDeviceQueueCount(gpu, pCount);
+   return res;
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueProperties(
+                                            VkPhysicalDevice gpu,
+                                            uint32_t count,
+                                            VkPhysicalDeviceQueueProperties* pQueueProperties)
 {
     const VkLayerInstanceDispatchTable *disp;
     VkResult res;
 
     disp = loader_get_instance_dispatch(gpu);
-    res = disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
+    res = disp->GetPhysicalDeviceQueueProperties(gpu, count, pQueueProperties);
     return res;
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLimits(
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
                                             VkPhysicalDevice gpu,
-                                            VkPhysicalDeviceLimits *pLimits)
+                                            VkPhysicalDeviceMemoryProperties* pMemoryProperties)
 {
     const VkLayerInstanceDispatchTable *disp;
     VkResult res;
 
     disp = loader_get_instance_dispatch(gpu);
-    res = disp->GetPhysicalDeviceLimits(gpu, pLimits);
+    res = disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
     return res;
 }
 
@@ -421,40 +436,40 @@ LOADER_EXPORT VkResult VKAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDevi
     return disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
+LOADER_EXPORT VkResult VKAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
+    return disp->BindBufferMemory(device, buffer, mem, offset);
 }
 
-LOADER_EXPORT VkResult VKAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
+LOADER_EXPORT VkResult VKAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
+    return disp->BindImageMemory(device, image, mem, offset);
 }
 
-LOADER_EXPORT VkResult VKAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset)
+LOADER_EXPORT VkResult VKAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->BindBufferMemory(device, buffer, mem, offset);
+    return disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
 }
 
-LOADER_EXPORT VkResult VKAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset)
+LOADER_EXPORT VkResult VKAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->BindImageMemory(device, image, mem, offset);
+    return disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
 LOADER_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
@@ -475,22 +490,22 @@ LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPh
     return disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
+    return disp->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
+    return disp->QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
 }
 
 LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo)
@@ -1044,6 +1059,51 @@ LOADER_EXPORT VkResult VKAPI vkDestroyDynamicDepthStencilState(VkDevice device,
     return disp->DestroyDynamicDepthStencilState(device, dynamicDepthStencilState);
 }
 
+LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    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;
+
+    disp = loader_get_dispatch(device);
+
+    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 VkResult VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
+}
+
 LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
 {
     const VkLayerDispatchTable *disp;
@@ -1176,22 +1236,22 @@ LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipeli
     disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
+LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+    disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+    disp->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
 LOADER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
@@ -1437,40 +1497,13 @@ LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQuer
     disp->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
-{
-    const VkLayerDispatchTable *disp;
-
-    disp = loader_get_dispatch(device);
-
-    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;
-
-    disp = loader_get_dispatch(device);
-
-    return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
-}
-
-LOADER_EXPORT VkResult VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
+LOADER_EXPORT void VKAPI vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(device);
+    disp = loader_get_dispatch(cmdBuffer);
 
-    return disp->DestroyRenderPass(device, renderPass);
+    return disp->CmdPushConstants(cmdBuffer, layout, stageFlags, start, length, values);
 }
 
 LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)