loader: No longer generate code, instead directly check in source code

5 files changed, 2077 insertions, 19 deletions

diff --git a/loader/CMakeLists.txt b/loader/CMakeLists.txt
index 274bc4dc..9c1c2314 100644
--- a/loader/CMakeLists.txt
+++ b/loader/CMakeLists.txt
@@ -1,20 +1,3 @@
-add_custom_command(OUTPUT dispatch.c
-	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py loader-entrypoints > dispatch.c
-	DEPENDS ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py
-                ${PROJECT_SOURCE_DIR}/include/vkIcd.h)
-
-add_custom_command(OUTPUT table_ops.h
-	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py dispatch-table-ops loader > table_ops.h
-	DEPENDS ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py)
-
-add_custom_command(OUTPUT vulkan.def
-	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py win-def-file vulkan all > vulkan.def
-	DEPENDS ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py)
-
-add_custom_command(OUTPUT gpa_helper.h
-	COMMAND ${PYTHON_CMD} ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py loader-get-proc-addr loader > gpa_helper.h
-	DEPENDS ${PROJECT_SOURCE_DIR}/loader/vk-loader-generate.py ${PROJECT_SOURCE_DIR}/vulkan.py)
-
 include_directories(
 	${CMAKE_CURRENT_SOURCE_DIR}
 	${CMAKE_CURRENT_BINARY_DIR}
@@ -27,7 +10,7 @@ set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG")
 if (WIN32)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -D_CRT_SECURE_NO_WARNINGS -DXCB_NVIDIA")
 
-    add_library(vulkan SHARED loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h gpa_helper.h vulkan.def)
+    add_library(vulkan SHARED loader.c loader.h loader_platform.h dirent_on_windows.c trampoline.c table_ops.h gpa_helper.h vulkan.def)
     set_target_properties(vulkan PROPERTIES LINK_FLAGS "/DEF:${PROJECT_SOURCE_DIR}/loader/vulkan.def")
     add_library(VKstatic STATIC loader.c loader.h dirent_on_windows.c dispatch.c table_ops.h gpa_helper.h)
     set_target_properties(VKstatic PROPERTIES OUTPUT_NAME VKstatic)
@@ -36,7 +19,7 @@ endif()
 if (NOT WIN32)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DVK_PROTOTYPES -Wpointer-arith")
 
-    add_library(vulkan SHARED loader.c dispatch.c table_ops.h gpa_helper.h)
+    add_library(vulkan SHARED loader.c trampoline.c loader.h loader_platform.h table_ops.h gpa_helper.h)
     set_target_properties(vulkan PROPERTIES SOVERSION 0)
     target_link_libraries(vulkan -ldl -lpthread)
 endif()
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
new file mode 100644
index 00000000..b2a6f311
--- /dev/null
+++ b/loader/gpa_helper.h
@@ -0,0 +1,337 @@
+/*
+ * Vulkan
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <string.h>
+
+static inline void* globalGetProcAddr(const char *name)
+{
+    if (!name || name[0] != 'v' || name[1] != 'k')
+        return NULL;
+
+    name += 2;
+    if (!strcmp(name, "CreateInstance"))
+        return (void*) vkCreateInstance;
+    if (!strcmp(name, "DestroyInstance"))
+        return (void*) vkDestroyInstance;
+    if (!strcmp(name, "EnumeratePhysicalDevices"))
+        return (void*) vkEnumeratePhysicalDevices;
+    if (!strcmp(name, "GetPhysicalDeviceInfo"))
+        return (void*) vkGetPhysicalDeviceInfo;
+    if (!strcmp(name, "GetProcAddr"))
+        return (void*) vkGetProcAddr;
+    if (!strcmp(name, "CreateDevice"))
+        return (void*) vkCreateDevice;
+    if (!strcmp(name, "DestroyDevice"))
+        return (void*) vkDestroyDevice;
+    if (!strcmp(name, "GetGlobalExtensionInfo"))
+        return (void*) vkGetGlobalExtensionInfo;
+    if (!strcmp(name, "GetPhysicalDeviceExtensionInfo"))
+        return (void*) vkGetPhysicalDeviceExtensionInfo;
+    if (!strcmp(name, "EnumerateLayers"))
+        return (void*) vkEnumerateLayers;
+    if (!strcmp(name, "GetDeviceQueue"))
+        return (void*) vkGetDeviceQueue;
+    if (!strcmp(name, "QueueSubmit"))
+        return (void*) vkQueueSubmit;
+    if (!strcmp(name, "QueueWaitIdle"))
+        return (void*) vkQueueWaitIdle;
+    if (!strcmp(name, "DeviceWaitIdle"))
+        return (void*) vkDeviceWaitIdle;
+    if (!strcmp(name, "AllocMemory"))
+        return (void*) vkAllocMemory;
+    if (!strcmp(name, "FreeMemory"))
+        return (void*) vkFreeMemory;
+    if (!strcmp(name, "SetMemoryPriority"))
+        return (void*) vkSetMemoryPriority;
+    if (!strcmp(name, "MapMemory"))
+        return (void*) vkMapMemory;
+    if (!strcmp(name, "UnmapMemory"))
+        return (void*) vkUnmapMemory;
+    if (!strcmp(name, "FlushMappedMemoryRanges"))
+        return (void*) vkFlushMappedMemoryRanges;
+    if (!strcmp(name, "InvalidateMappedMemoryRanges"))
+        return (void*) vkInvalidateMappedMemoryRanges;
+    if (!strcmp(name, "PinSystemMemory"))
+        return (void*) vkPinSystemMemory;
+    if (!strcmp(name, "GetMultiDeviceCompatibility"))
+        return (void*) vkGetMultiDeviceCompatibility;
+    if (!strcmp(name, "OpenSharedMemory"))
+        return (void*) vkOpenSharedMemory;
+    if (!strcmp(name, "OpenSharedSemaphore"))
+        return (void*) vkOpenSharedSemaphore;
+    if (!strcmp(name, "OpenPeerMemory"))
+        return (void*) vkOpenPeerMemory;
+    if (!strcmp(name, "OpenPeerImage"))
+        return (void*) vkOpenPeerImage;
+    if (!strcmp(name, "DestroyObject"))
+        return (void*) vkDestroyObject;
+    if (!strcmp(name, "GetObjectInfo"))
+        return (void*) vkGetObjectInfo;
+    if (!strcmp(name, "QueueBindObjectMemory"))
+        return (void*) vkQueueBindObjectMemory;
+    if (!strcmp(name, "QueueBindObjectMemoryRange"))
+        return (void*) vkQueueBindObjectMemoryRange;
+    if (!strcmp(name, "QueueBindImageMemoryRange"))
+        return (void*) vkQueueBindImageMemoryRange;
+    if (!strcmp(name, "CreateFence"))
+        return (void*) vkCreateFence;
+    if (!strcmp(name, "ResetFences"))
+        return (void*) vkResetFences;
+    if (!strcmp(name, "GetFenceStatus"))
+        return (void*) vkGetFenceStatus;
+    if (!strcmp(name, "WaitForFences"))
+        return (void*) vkWaitForFences;
+    if (!strcmp(name, "CreateSemaphore"))
+        return (void*) vkCreateSemaphore;
+    if (!strcmp(name, "QueueSignalSemaphore"))
+        return (void*) vkQueueSignalSemaphore;
+    if (!strcmp(name, "QueueWaitSemaphore"))
+        return (void*) vkQueueWaitSemaphore;
+    if (!strcmp(name, "CreateEvent"))
+        return (void*) vkCreateEvent;
+    if (!strcmp(name, "GetEventStatus"))
+        return (void*) vkGetEventStatus;
+    if (!strcmp(name, "SetEvent"))
+        return (void*) vkSetEvent;
+    if (!strcmp(name, "ResetEvent"))
+        return (void*) vkResetEvent;
+    if (!strcmp(name, "CreateQueryPool"))
+        return (void*) vkCreateQueryPool;
+    if (!strcmp(name, "GetQueryPoolResults"))
+        return (void*) vkGetQueryPoolResults;
+    if (!strcmp(name, "GetFormatInfo"))
+        return (void*) vkGetFormatInfo;
+    if (!strcmp(name, "CreateBuffer"))
+        return (void*) vkCreateBuffer;
+    if (!strcmp(name, "CreateBufferView"))
+        return (void*) vkCreateBufferView;
+    if (!strcmp(name, "CreateImage"))
+        return (void*) vkCreateImage;
+    if (!strcmp(name, "GetImageSubresourceInfo"))
+        return (void*) vkGetImageSubresourceInfo;
+    if (!strcmp(name, "CreateImageView"))
+        return (void*) vkCreateImageView;
+    if (!strcmp(name, "CreateColorAttachmentView"))
+        return (void*) vkCreateColorAttachmentView;
+    if (!strcmp(name, "CreateDepthStencilView"))
+        return (void*) vkCreateDepthStencilView;
+    if (!strcmp(name, "CreateShader"))
+        return (void*) vkCreateShader;
+    if (!strcmp(name, "CreateGraphicsPipeline"))
+        return (void*) vkCreateGraphicsPipeline;
+    if (!strcmp(name, "CreateGraphicsPipelineDerivative"))
+        return (void*) vkCreateGraphicsPipelineDerivative;
+    if (!strcmp(name, "CreateComputePipeline"))
+        return (void*) vkCreateComputePipeline;
+    if (!strcmp(name, "StorePipeline"))
+        return (void*) vkStorePipeline;
+    if (!strcmp(name, "LoadPipeline"))
+        return (void*) vkLoadPipeline;
+    if (!strcmp(name, "LoadPipelineDerivative"))
+        return (void*) vkLoadPipelineDerivative;
+    if (!strcmp(name, "CreatePipelineLayout"))
+        return (void*) vkCreatePipelineLayout;
+    if (!strcmp(name, "CreateSampler"))
+        return (void*) vkCreateSampler;
+    if (!strcmp(name, "CreateDescriptorSetLayout"))
+        return (void*) vkCreateDescriptorSetLayout;
+    if (!strcmp(name, "BeginDescriptorPoolUpdate"))
+        return (void*) vkBeginDescriptorPoolUpdate;
+    if (!strcmp(name, "EndDescriptorPoolUpdate"))
+        return (void*) vkEndDescriptorPoolUpdate;
+    if (!strcmp(name, "CreateDescriptorPool"))
+        return (void*) vkCreateDescriptorPool;
+    if (!strcmp(name, "ResetDescriptorPool"))
+        return (void*) vkResetDescriptorPool;
+    if (!strcmp(name, "AllocDescriptorSets"))
+        return (void*) vkAllocDescriptorSets;
+    if (!strcmp(name, "ClearDescriptorSets"))
+        return (void*) vkClearDescriptorSets;
+    if (!strcmp(name, "UpdateDescriptors"))
+        return (void*) vkUpdateDescriptors;
+    if (!strcmp(name, "CreateDynamicViewportState"))
+        return (void*) vkCreateDynamicViewportState;
+    if (!strcmp(name, "CreateDynamicRasterState"))
+        return (void*) vkCreateDynamicRasterState;
+    if (!strcmp(name, "CreateDynamicColorBlendState"))
+        return (void*) vkCreateDynamicColorBlendState;
+    if (!strcmp(name, "CreateDynamicDepthStencilState"))
+        return (void*) vkCreateDynamicDepthStencilState;
+    if (!strcmp(name, "CreateCommandBuffer"))
+        return (void*) vkCreateCommandBuffer;
+    if (!strcmp(name, "BeginCommandBuffer"))
+        return (void*) vkBeginCommandBuffer;
+    if (!strcmp(name, "EndCommandBuffer"))
+        return (void*) vkEndCommandBuffer;
+    if (!strcmp(name, "ResetCommandBuffer"))
+        return (void*) vkResetCommandBuffer;
+    if (!strcmp(name, "CmdBindPipeline"))
+        return (void*) vkCmdBindPipeline;
+    if (!strcmp(name, "CmdBindDynamicStateObject"))
+        return (void*) vkCmdBindDynamicStateObject;
+    if (!strcmp(name, "CmdBindDescriptorSets"))
+        return (void*) vkCmdBindDescriptorSets;
+    if (!strcmp(name, "CmdBindVertexBuffers"))
+        return (void*) vkCmdBindVertexBuffers;
+    if (!strcmp(name, "CmdBindIndexBuffer"))
+        return (void*) vkCmdBindIndexBuffer;
+    if (!strcmp(name, "CmdDraw"))
+        return (void*) vkCmdDraw;
+    if (!strcmp(name, "CmdDrawIndexed"))
+        return (void*) vkCmdDrawIndexed;
+    if (!strcmp(name, "CmdDrawIndirect"))
+        return (void*) vkCmdDrawIndirect;
+    if (!strcmp(name, "CmdDrawIndexedIndirect"))
+        return (void*) vkCmdDrawIndexedIndirect;
+    if (!strcmp(name, "CmdDispatch"))
+        return (void*) vkCmdDispatch;
+    if (!strcmp(name, "CmdDispatchIndirect"))
+        return (void*) vkCmdDispatchIndirect;
+    if (!strcmp(name, "CmdCopyBuffer"))
+        return (void*) vkCmdCopyBuffer;
+    if (!strcmp(name, "CmdCopyImage"))
+        return (void*) vkCmdCopyImage;
+    if (!strcmp(name, "CmdBlitImage"))
+        return (void*) vkCmdBlitImage;
+    if (!strcmp(name, "CmdCopyBufferToImage"))
+        return (void*) vkCmdCopyBufferToImage;
+    if (!strcmp(name, "CmdCopyImageToBuffer"))
+        return (void*) vkCmdCopyImageToBuffer;
+    if (!strcmp(name, "CmdCloneImageData"))
+        return (void*) vkCmdCloneImageData;
+    if (!strcmp(name, "CmdUpdateBuffer"))
+        return (void*) vkCmdUpdateBuffer;
+    if (!strcmp(name, "CmdFillBuffer"))
+        return (void*) vkCmdFillBuffer;
+    if (!strcmp(name, "CmdClearColorImage"))
+        return (void*) vkCmdClearColorImage;
+    if (!strcmp(name, "CmdClearDepthStencil"))
+        return (void*) vkCmdClearDepthStencil;
+    if (!strcmp(name, "CmdResolveImage"))
+        return (void*) vkCmdResolveImage;
+    if (!strcmp(name, "CmdSetEvent"))
+        return (void*) vkCmdSetEvent;
+    if (!strcmp(name, "CmdResetEvent"))
+        return (void*) vkCmdResetEvent;
+    if (!strcmp(name, "CmdWaitEvents"))
+        return (void*) vkCmdWaitEvents;
+    if (!strcmp(name, "CmdPipelineBarrier"))
+        return (void*) vkCmdPipelineBarrier;
+    if (!strcmp(name, "CmdBeginQuery"))
+        return (void*) vkCmdBeginQuery;
+    if (!strcmp(name, "CmdEndQuery"))
+        return (void*) vkCmdEndQuery;
+    if (!strcmp(name, "CmdResetQueryPool"))
+        return (void*) vkCmdResetQueryPool;
+    if (!strcmp(name, "CmdWriteTimestamp"))
+        return (void*) vkCmdWriteTimestamp;
+    if (!strcmp(name, "CmdCopyQueryPoolResults"))
+        return (void*) vkCmdCopyQueryPoolResults;
+    if (!strcmp(name, "CmdInitAtomicCounters"))
+        return (void*) vkCmdInitAtomicCounters;
+    if (!strcmp(name, "CmdLoadAtomicCounters"))
+        return (void*) vkCmdLoadAtomicCounters;
+    if (!strcmp(name, "CmdSaveAtomicCounters"))
+        return (void*) vkCmdSaveAtomicCounters;
+    if (!strcmp(name, "CreateFramebuffer"))
+        return (void*) vkCreateFramebuffer;
+    if (!strcmp(name, "CreateRenderPass"))
+        return (void*) vkCreateRenderPass;
+    if (!strcmp(name, "CmdBeginRenderPass"))
+        return (void*) vkCmdBeginRenderPass;
+    if (!strcmp(name, "CmdEndRenderPass"))
+        return (void*) vkCmdEndRenderPass;
+    if (!strcmp(name, "DbgSetValidationLevel"))
+        return (void*) vkDbgSetValidationLevel;
+    if (!strcmp(name, "DbgRegisterMsgCallback"))
+        return (void*) vkDbgRegisterMsgCallback;
+    if (!strcmp(name, "DbgUnregisterMsgCallback"))
+        return (void*) vkDbgUnregisterMsgCallback;
+    if (!strcmp(name, "DbgSetMessageFilter"))
+        return (void*) vkDbgSetMessageFilter;
+    if (!strcmp(name, "DbgSetObjectTag"))
+        return (void*) vkDbgSetObjectTag;
+    if (!strcmp(name, "DbgSetGlobalOption"))
+        return (void*) vkDbgSetGlobalOption;
+    if (!strcmp(name, "DbgSetDeviceOption"))
+        return (void*) vkDbgSetDeviceOption;
+    if (!strcmp(name, "CmdDbgMarkerBegin"))
+        return (void*) vkCmdDbgMarkerBegin;
+    if (!strcmp(name, "CmdDbgMarkerEnd"))
+        return (void*) vkCmdDbgMarkerEnd;
+    if (!strcmp(name, "GetDisplayInfoWSI"))
+        return (void*) vkGetDisplayInfoWSI;
+    if (!strcmp(name, "CreateSwapChainWSI"))
+        return (void*) vkCreateSwapChainWSI;
+    if (!strcmp(name, "DestroySwapChainWSI"))
+        return (void*) vkDestroySwapChainWSI;
+    if (!strcmp(name, "GetSwapChainInfoWSI"))
+        return (void*) vkGetSwapChainInfoWSI;
+    if (!strcmp(name, "QueuePresentWSI"))
+        return (void*) vkQueuePresentWSI;
+
+    return NULL;
+}
+
+/* These functions require special handling by the loader.
+*  They are not just generic trampoline code entrypoints.
+*  Thus GPA must return loader entrypoint for these instead of first function
+*  in the chain. */
+static inline void *loader_non_passthrough_gpa(const char *name)
+{
+    if (!name || name[0] != 'v' || name[1] != 'k')
+        return NULL;
+
+    name += 2;
+    if (!strcmp(name, "CreateInstance"))
+        return (void*) vkCreateInstance;
+    if (!strcmp(name, "DestroyInstance"))
+        return (void*) vkDestroyInstance;
+    if (!strcmp(name, "EnumeratePhysicalDevices"))
+        return (void*) vkEnumeratePhysicalDevices;
+    if (!strcmp(name, "GetPhysicalDeviceInfo"))
+        return (void*) vkGetPhysicalDeviceInfo;
+    if (!strcmp(name, "GetProcAddr"))
+        return (void*) vkGetProcAddr;
+    if (!strcmp(name, "CreateDevice"))
+        return (void*) vkCreateDevice;
+    if (!strcmp(name, "GetGlobalExtensionInfo"))
+        return (void*) vkGetGlobalExtensionInfo;
+    if (!strcmp(name, "EnumerateLayers"))
+        return (void*) vkEnumerateLayers;
+    if (!strcmp(name, "GetDeviceQueue"))
+        return (void*) vkGetDeviceQueue;
+    if (!strcmp(name, "CreateCommandBuffer"))
+        return (void*) vkCreateCommandBuffer;
+    if (!strcmp(name, "DbgRegisterMsgCallback"))
+        return (void*) vkDbgRegisterMsgCallback;
+    if (!strcmp(name, "DbgUnregisterMsgCallback"))
+        return (void*) vkDbgUnregisterMsgCallback;
+    if (!strcmp(name, "DbgSetGlobalOption"))
+        return (void*) vkDbgSetGlobalOption;
+    if (!strcmp(name, "CreateSwapChainWSI"))
+        return (void*) vkCreateSwapChainWSI;
+
+    return NULL;
+}
diff --git a/loader/table_ops.h b/loader/table_ops.h
new file mode 100644
index 00000000..3a3535d2
--- /dev/null
+++ b/loader/table_ops.h
@@ -0,0 +1,431 @@
+/*
+ * Vulkan
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <vulkan.h>
+#include <vkLayer.h>
+#include <string.h>
+#include "loader_platform.h"
+
+static inline void loader_initialize_dispatch_table(VkLayerDispatchTable *table,
+                                                    PFN_vkGetProcAddr gpa,
+                                                    VkPhysicalDevice gpu)
+{
+    table->CreateInstance = (PFN_vkCreateInstance) gpa(gpu, "vkCreateInstance");
+    table->DestroyInstance = (PFN_vkDestroyInstance) gpa(gpu, "vkDestroyInstance");
+    table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) gpa(gpu, "vkEnumeratePhysicalDevices");
+    table->GetPhysicalDeviceInfo = (PFN_vkGetPhysicalDeviceInfo) gpa(gpu, "vkGetPhysicalDeviceInfo");
+    table->GetProcAddr = (PFN_vkGetProcAddr) gpa(gpu, "vkGetProcAddr");
+    table->CreateDevice = (PFN_vkCreateDevice) gpa(gpu, "vkCreateDevice");
+    table->DestroyDevice = (PFN_vkDestroyDevice) gpa(gpu, "vkDestroyDevice");
+    table->GetGlobalExtensionInfo = vkGetGlobalExtensionInfo; /* non-dispatchable */
+    table->GetPhysicalDeviceExtensionInfo = (PFN_vkGetPhysicalDeviceExtensionInfo) gpa(gpu, "vkGetPhysicalDeviceExtensionInfo");
+    table->EnumerateLayers = (PFN_vkEnumerateLayers) gpa(gpu, "vkEnumerateLayers");
+    table->GetDeviceQueue = (PFN_vkGetDeviceQueue) gpa(gpu, "vkGetDeviceQueue");
+    table->QueueSubmit = (PFN_vkQueueSubmit) gpa(gpu, "vkQueueSubmit");
+    table->QueueWaitIdle = (PFN_vkQueueWaitIdle) gpa(gpu, "vkQueueWaitIdle");
+    table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle) gpa(gpu, "vkDeviceWaitIdle");
+    table->AllocMemory = (PFN_vkAllocMemory) gpa(gpu, "vkAllocMemory");
+    table->FreeMemory = (PFN_vkFreeMemory) gpa(gpu, "vkFreeMemory");
+    table->SetMemoryPriority = (PFN_vkSetMemoryPriority) gpa(gpu, "vkSetMemoryPriority");
+    table->MapMemory = (PFN_vkMapMemory) gpa(gpu, "vkMapMemory");
+    table->UnmapMemory = (PFN_vkUnmapMemory) gpa(gpu, "vkUnmapMemory");
+    table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) gpa(gpu, "vkFlushMappedMemoryRanges");
+    table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) gpa(gpu, "vkInvalidateMappedMemoryRanges");
+    table->PinSystemMemory = (PFN_vkPinSystemMemory) gpa(gpu, "vkPinSystemMemory");
+    table->GetMultiDeviceCompatibility = (PFN_vkGetMultiDeviceCompatibility) gpa(gpu, "vkGetMultiDeviceCompatibility");
+    table->OpenSharedMemory = (PFN_vkOpenSharedMemory) gpa(gpu, "vkOpenSharedMemory");
+    table->OpenSharedSemaphore = (PFN_vkOpenSharedSemaphore) gpa(gpu, "vkOpenSharedSemaphore");
+    table->OpenPeerMemory = (PFN_vkOpenPeerMemory) gpa(gpu, "vkOpenPeerMemory");
+    table->OpenPeerImage = (PFN_vkOpenPeerImage) gpa(gpu, "vkOpenPeerImage");
+    table->DestroyObject = (PFN_vkDestroyObject) gpa(gpu, "vkDestroyObject");
+    table->GetObjectInfo = (PFN_vkGetObjectInfo) gpa(gpu, "vkGetObjectInfo");
+    table->QueueBindObjectMemory = (PFN_vkQueueBindObjectMemory) gpa(gpu, "vkQueueBindObjectMemory");
+    table->QueueBindObjectMemoryRange = (PFN_vkQueueBindObjectMemoryRange) gpa(gpu, "vkQueueBindObjectMemoryRange");
+    table->QueueBindImageMemoryRange = (PFN_vkQueueBindImageMemoryRange) gpa(gpu, "vkQueueBindImageMemoryRange");
+    table->CreateFence = (PFN_vkCreateFence) gpa(gpu, "vkCreateFence");
+    table->ResetFences = (PFN_vkResetFences) gpa(gpu, "vkResetFences");
+    table->GetFenceStatus = (PFN_vkGetFenceStatus) gpa(gpu, "vkGetFenceStatus");
+    table->WaitForFences = (PFN_vkWaitForFences) gpa(gpu, "vkWaitForFences");
+    table->CreateSemaphore = (PFN_vkCreateSemaphore) gpa(gpu, "vkCreateSemaphore");
+    table->QueueSignalSemaphore = (PFN_vkQueueSignalSemaphore) gpa(gpu, "vkQueueSignalSemaphore");
+    table->QueueWaitSemaphore = (PFN_vkQueueWaitSemaphore) gpa(gpu, "vkQueueWaitSemaphore");
+    table->CreateEvent = (PFN_vkCreateEvent) gpa(gpu, "vkCreateEvent");
+    table->GetEventStatus = (PFN_vkGetEventStatus) gpa(gpu, "vkGetEventStatus");
+    table->SetEvent = (PFN_vkSetEvent) gpa(gpu, "vkSetEvent");
+    table->ResetEvent = (PFN_vkResetEvent) gpa(gpu, "vkResetEvent");
+    table->CreateQueryPool = (PFN_vkCreateQueryPool) gpa(gpu, "vkCreateQueryPool");
+    table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults) gpa(gpu, "vkGetQueryPoolResults");
+    table->GetFormatInfo = (PFN_vkGetFormatInfo) gpa(gpu, "vkGetFormatInfo");
+    table->CreateBuffer = (PFN_vkCreateBuffer) gpa(gpu, "vkCreateBuffer");
+    table->CreateBufferView = (PFN_vkCreateBufferView) gpa(gpu, "vkCreateBufferView");
+    table->CreateImage = (PFN_vkCreateImage) gpa(gpu, "vkCreateImage");
+    table->GetImageSubresourceInfo = (PFN_vkGetImageSubresourceInfo) gpa(gpu, "vkGetImageSubresourceInfo");
+    table->CreateImageView = (PFN_vkCreateImageView) gpa(gpu, "vkCreateImageView");
+    table->CreateColorAttachmentView = (PFN_vkCreateColorAttachmentView) gpa(gpu, "vkCreateColorAttachmentView");
+    table->CreateDepthStencilView = (PFN_vkCreateDepthStencilView) gpa(gpu, "vkCreateDepthStencilView");
+    table->CreateShader = (PFN_vkCreateShader) gpa(gpu, "vkCreateShader");
+    table->CreateGraphicsPipeline = (PFN_vkCreateGraphicsPipeline) gpa(gpu, "vkCreateGraphicsPipeline");
+    table->CreateGraphicsPipelineDerivative = (PFN_vkCreateGraphicsPipelineDerivative) gpa(gpu, "vkCreateGraphicsPipelineDerivative");
+    table->CreateComputePipeline = (PFN_vkCreateComputePipeline) gpa(gpu, "vkCreateComputePipeline");
+    table->StorePipeline = (PFN_vkStorePipeline) gpa(gpu, "vkStorePipeline");
+    table->LoadPipeline = (PFN_vkLoadPipeline) gpa(gpu, "vkLoadPipeline");
+    table->LoadPipelineDerivative = (PFN_vkLoadPipelineDerivative) gpa(gpu, "vkLoadPipelineDerivative");
+    table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout) gpa(gpu, "vkCreatePipelineLayout");
+    table->CreateSampler = (PFN_vkCreateSampler) gpa(gpu, "vkCreateSampler");
+    table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) gpa(gpu, "vkCreateDescriptorSetLayout");
+    table->BeginDescriptorPoolUpdate = (PFN_vkBeginDescriptorPoolUpdate) gpa(gpu, "vkBeginDescriptorPoolUpdate");
+    table->EndDescriptorPoolUpdate = (PFN_vkEndDescriptorPoolUpdate) gpa(gpu, "vkEndDescriptorPoolUpdate");
+    table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool) gpa(gpu, "vkCreateDescriptorPool");
+    table->ResetDescriptorPool = (PFN_vkResetDescriptorPool) gpa(gpu, "vkResetDescriptorPool");
+    table->AllocDescriptorSets = (PFN_vkAllocDescriptorSets) gpa(gpu, "vkAllocDescriptorSets");
+    table->ClearDescriptorSets = (PFN_vkClearDescriptorSets) gpa(gpu, "vkClearDescriptorSets");
+    table->UpdateDescriptors = (PFN_vkUpdateDescriptors) gpa(gpu, "vkUpdateDescriptors");
+    table->CreateDynamicViewportState = (PFN_vkCreateDynamicViewportState) gpa(gpu, "vkCreateDynamicViewportState");
+    table->CreateDynamicRasterState = (PFN_vkCreateDynamicRasterState) gpa(gpu, "vkCreateDynamicRasterState");
+    table->CreateDynamicColorBlendState = (PFN_vkCreateDynamicColorBlendState) gpa(gpu, "vkCreateDynamicColorBlendState");
+    table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(gpu, "vkCreateDynamicDepthStencilState");
+    table->CreateCommandBuffer = (PFN_vkCreateCommandBuffer) gpa(gpu, "vkCreateCommandBuffer");
+    table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(gpu, "vkBeginCommandBuffer");
+    table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(gpu, "vkEndCommandBuffer");
+    table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(gpu, "vkResetCommandBuffer");
+    table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(gpu, "vkCmdBindPipeline");
+    table->CmdBindDynamicStateObject = (PFN_vkCmdBindDynamicStateObject) gpa(gpu, "vkCmdBindDynamicStateObject");
+    table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(gpu, "vkCmdBindDescriptorSets");
+    table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) gpa(gpu, "vkCmdBindVertexBuffers");
+    table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) gpa(gpu, "vkCmdBindIndexBuffer");
+    table->CmdDraw = (PFN_vkCmdDraw) gpa(gpu, "vkCmdDraw");
+    table->CmdDrawIndexed = (PFN_vkCmdDrawIndexed) gpa(gpu, "vkCmdDrawIndexed");
+    table->CmdDrawIndirect = (PFN_vkCmdDrawIndirect) gpa(gpu, "vkCmdDrawIndirect");
+    table->CmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect) gpa(gpu, "vkCmdDrawIndexedIndirect");
+    table->CmdDispatch = (PFN_vkCmdDispatch) gpa(gpu, "vkCmdDispatch");
+    table->CmdDispatchIndirect = (PFN_vkCmdDispatchIndirect) gpa(gpu, "vkCmdDispatchIndirect");
+    table->CmdCopyBuffer = (PFN_vkCmdCopyBuffer) gpa(gpu, "vkCmdCopyBuffer");
+    table->CmdCopyImage = (PFN_vkCmdCopyImage) gpa(gpu, "vkCmdCopyImage");
+    table->CmdBlitImage = (PFN_vkCmdBlitImage) gpa(gpu, "vkCmdBlitImage");
+    table->CmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage) gpa(gpu, "vkCmdCopyBufferToImage");
+    table->CmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer) gpa(gpu, "vkCmdCopyImageToBuffer");
+    table->CmdCloneImageData = (PFN_vkCmdCloneImageData) gpa(gpu, "vkCmdCloneImageData");
+    table->CmdUpdateBuffer = (PFN_vkCmdUpdateBuffer) gpa(gpu, "vkCmdUpdateBuffer");
+    table->CmdFillBuffer = (PFN_vkCmdFillBuffer) gpa(gpu, "vkCmdFillBuffer");
+    table->CmdClearColorImage = (PFN_vkCmdClearColorImage) gpa(gpu, "vkCmdClearColorImage");
+    table->CmdClearDepthStencil = (PFN_vkCmdClearDepthStencil) gpa(gpu, "vkCmdClearDepthStencil");
+    table->CmdResolveImage = (PFN_vkCmdResolveImage) gpa(gpu, "vkCmdResolveImage");
+    table->CmdSetEvent = (PFN_vkCmdSetEvent) gpa(gpu, "vkCmdSetEvent");
+    table->CmdResetEvent = (PFN_vkCmdResetEvent) gpa(gpu, "vkCmdResetEvent");
+    table->CmdWaitEvents = (PFN_vkCmdWaitEvents) gpa(gpu, "vkCmdWaitEvents");
+    table->CmdPipelineBarrier = (PFN_vkCmdPipelineBarrier) gpa(gpu, "vkCmdPipelineBarrier");
+    table->CmdBeginQuery = (PFN_vkCmdBeginQuery) gpa(gpu, "vkCmdBeginQuery");
+    table->CmdEndQuery = (PFN_vkCmdEndQuery) gpa(gpu, "vkCmdEndQuery");
+    table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool) gpa(gpu, "vkCmdResetQueryPool");
+    table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) gpa(gpu, "vkCmdWriteTimestamp");
+    table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) gpa(gpu, "vkCmdCopyQueryPoolResults");
+    table->CmdInitAtomicCounters = (PFN_vkCmdInitAtomicCounters) gpa(gpu, "vkCmdInitAtomicCounters");
+    table->CmdLoadAtomicCounters = (PFN_vkCmdLoadAtomicCounters) gpa(gpu, "vkCmdLoadAtomicCounters");
+    table->CmdSaveAtomicCounters = (PFN_vkCmdSaveAtomicCounters) gpa(gpu, "vkCmdSaveAtomicCounters");
+    table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(gpu, "vkCreateFramebuffer");
+    table->CreateRenderPass = (PFN_vkCreateRenderPass) gpa(gpu, "vkCreateRenderPass");
+    table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) gpa(gpu, "vkCmdBeginRenderPass");
+    table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass) gpa(gpu, "vkCmdEndRenderPass");
+    table->DbgSetValidationLevel = (PFN_vkDbgSetValidationLevel) gpa(gpu, "vkDbgSetValidationLevel");
+    table->DbgRegisterMsgCallback = (PFN_vkDbgRegisterMsgCallback) gpa(gpu, "vkDbgRegisterMsgCallback");
+    table->DbgUnregisterMsgCallback = (PFN_vkDbgUnregisterMsgCallback) gpa(gpu, "vkDbgUnregisterMsgCallback");
+    table->DbgSetMessageFilter = (PFN_vkDbgSetMessageFilter) gpa(gpu, "vkDbgSetMessageFilter");
+    table->DbgSetObjectTag = (PFN_vkDbgSetObjectTag) gpa(gpu, "vkDbgSetObjectTag");
+    table->DbgSetGlobalOption = (PFN_vkDbgSetGlobalOption) gpa(gpu, "vkDbgSetGlobalOption");
+    table->DbgSetDeviceOption = (PFN_vkDbgSetDeviceOption) gpa(gpu, "vkDbgSetDeviceOption");
+    table->CmdDbgMarkerBegin = (PFN_vkCmdDbgMarkerBegin) gpa(gpu, "vkCmdDbgMarkerBegin");
+    table->CmdDbgMarkerEnd = (PFN_vkCmdDbgMarkerEnd) gpa(gpu, "vkCmdDbgMarkerEnd");
+    table->GetDisplayInfoWSI = (PFN_vkGetDisplayInfoWSI) gpa(gpu, "vkGetDisplayInfoWSI");
+    table->CreateSwapChainWSI = (PFN_vkCreateSwapChainWSI) gpa(gpu, "vkCreateSwapChainWSI");
+    table->DestroySwapChainWSI = (PFN_vkDestroySwapChainWSI) gpa(gpu, "vkDestroySwapChainWSI");
+    table->GetSwapChainInfoWSI = (PFN_vkGetSwapChainInfoWSI) gpa(gpu, "vkGetSwapChainInfoWSI");
+    table->QueuePresentWSI = (PFN_vkQueuePresentWSI) gpa(gpu, "vkQueuePresentWSI");
+}
+
+static inline void *loader_lookup_dispatch_table(const VkLayerDispatchTable *table,
+                                                 const char *name)
+{
+    if (!name || name[0] != 'v' || name[1] != 'k')
+        return NULL;
+
+    name += 2;
+    if (!strcmp(name, "DestroyInstance"))
+        return (void *) table->DestroyInstance;
+    if (!strcmp(name, "EnumeratePhysicalDevices"))
+        return (void *) table->EnumeratePhysicalDevices;
+    if (!strcmp(name, "GetPhysicalDeviceInfo"))
+        return (void *) table->GetPhysicalDeviceInfo;
+    if (!strcmp(name, "GetProcAddr"))
+        return (void *) table->GetProcAddr;
+    if (!strcmp(name, "CreateDevice"))
+        return (void *) table->CreateDevice;
+    if (!strcmp(name, "DestroyDevice"))
+        return (void *) table->DestroyDevice;
+    if (!strcmp(name, "GetPhysicalDeviceExtensionInfo"))
+        return (void *) table->GetPhysicalDeviceExtensionInfo;
+    if (!strcmp(name, "EnumerateLayers"))
+        return (void *) table->EnumerateLayers;
+    if (!strcmp(name, "GetDeviceQueue"))
+        return (void *) table->GetDeviceQueue;
+    if (!strcmp(name, "QueueSubmit"))
+        return (void *) table->QueueSubmit;
+    if (!strcmp(name, "QueueWaitIdle"))
+        return (void *) table->QueueWaitIdle;
+    if (!strcmp(name, "DeviceWaitIdle"))
+        return (void *) table->DeviceWaitIdle;
+    if (!strcmp(name, "AllocMemory"))
+        return (void *) table->AllocMemory;
+    if (!strcmp(name, "FreeMemory"))
+        return (void *) table->FreeMemory;
+    if (!strcmp(name, "SetMemoryPriority"))
+        return (void *) table->SetMemoryPriority;
+    if (!strcmp(name, "MapMemory"))
+        return (void *) table->MapMemory;
+    if (!strcmp(name, "UnmapMemory"))
+        return (void *) table->UnmapMemory;
+    if (!strcmp(name, "FlushMappedMemoryRanges"))
+        return (void *) table->FlushMappedMemoryRanges;
+    if (!strcmp(name, "InvalidateMappedMemoryRanges"))
+        return (void *) table->InvalidateMappedMemoryRanges;
+    if (!strcmp(name, "PinSystemMemory"))
+        return (void *) table->PinSystemMemory;
+    if (!strcmp(name, "GetMultiDeviceCompatibility"))
+        return (void *) table->GetMultiDeviceCompatibility;
+    if (!strcmp(name, "OpenSharedMemory"))
+        return (void *) table->OpenSharedMemory;
+    if (!strcmp(name, "OpenSharedSemaphore"))
+        return (void *) table->OpenSharedSemaphore;
+    if (!strcmp(name, "OpenPeerMemory"))
+        return (void *) table->OpenPeerMemory;
+    if (!strcmp(name, "OpenPeerImage"))
+        return (void *) table->OpenPeerImage;
+    if (!strcmp(name, "DestroyObject"))
+        return (void *) table->DestroyObject;
+    if (!strcmp(name, "GetObjectInfo"))
+        return (void *) table->GetObjectInfo;
+    if (!strcmp(name, "QueueBindObjectMemory"))
+        return (void *) table->QueueBindObjectMemory;
+    if (!strcmp(name, "QueueBindObjectMemoryRange"))
+        return (void *) table->QueueBindObjectMemoryRange;
+    if (!strcmp(name, "QueueBindImageMemoryRange"))
+        return (void *) table->QueueBindImageMemoryRange;
+    if (!strcmp(name, "CreateFence"))
+        return (void *) table->CreateFence;
+    if (!strcmp(name, "ResetFences"))
+        return (void *) table->ResetFences;
+    if (!strcmp(name, "GetFenceStatus"))
+        return (void *) table->GetFenceStatus;
+    if (!strcmp(name, "WaitForFences"))
+        return (void *) table->WaitForFences;
+    if (!strcmp(name, "CreateSemaphore"))
+        return (void *) table->CreateSemaphore;
+    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, "GetEventStatus"))
+        return (void *) table->GetEventStatus;
+    if (!strcmp(name, "SetEvent"))
+        return (void *) table->SetEvent;
+    if (!strcmp(name, "ResetEvent"))
+        return (void *) table->ResetEvent;
+    if (!strcmp(name, "CreateQueryPool"))
+        return (void *) table->CreateQueryPool;
+    if (!strcmp(name, "GetQueryPoolResults"))
+        return (void *) table->GetQueryPoolResults;
+    if (!strcmp(name, "GetFormatInfo"))
+        return (void *) table->GetFormatInfo;
+    if (!strcmp(name, "CreateBuffer"))
+        return (void *) table->CreateBuffer;
+    if (!strcmp(name, "CreateBufferView"))
+        return (void *) table->CreateBufferView;
+    if (!strcmp(name, "CreateImage"))
+        return (void *) table->CreateImage;
+    if (!strcmp(name, "GetImageSubresourceInfo"))
+        return (void *) table->GetImageSubresourceInfo;
+    if (!strcmp(name, "CreateImageView"))
+        return (void *) table->CreateImageView;
+    if (!strcmp(name, "CreateColorAttachmentView"))
+        return (void *) table->CreateColorAttachmentView;
+    if (!strcmp(name, "CreateDepthStencilView"))
+        return (void *) table->CreateDepthStencilView;
+    if (!strcmp(name, "CreateShader"))
+        return (void *) table->CreateShader;
+    if (!strcmp(name, "CreateGraphicsPipeline"))
+        return (void *) table->CreateGraphicsPipeline;
+    if (!strcmp(name, "CreateGraphicsPipelineDerivative"))
+        return (void *) table->CreateGraphicsPipelineDerivative;
+    if (!strcmp(name, "CreateComputePipeline"))
+        return (void *) table->CreateComputePipeline;
+    if (!strcmp(name, "StorePipeline"))
+        return (void *) table->StorePipeline;
+    if (!strcmp(name, "LoadPipeline"))
+        return (void *) table->LoadPipeline;
+    if (!strcmp(name, "LoadPipelineDerivative"))
+        return (void *) table->LoadPipelineDerivative;
+    if (!strcmp(name, "CreatePipelineLayout"))
+        return (void *) table->CreatePipelineLayout;
+    if (!strcmp(name, "CreateSampler"))
+        return (void *) table->CreateSampler;
+    if (!strcmp(name, "CreateDescriptorSetLayout"))
+        return (void *) table->CreateDescriptorSetLayout;
+    if (!strcmp(name, "BeginDescriptorPoolUpdate"))
+        return (void *) table->BeginDescriptorPoolUpdate;
+    if (!strcmp(name, "EndDescriptorPoolUpdate"))
+        return (void *) table->EndDescriptorPoolUpdate;
+    if (!strcmp(name, "CreateDescriptorPool"))
+        return (void *) table->CreateDescriptorPool;
+    if (!strcmp(name, "ResetDescriptorPool"))
+        return (void *) table->ResetDescriptorPool;
+    if (!strcmp(name, "AllocDescriptorSets"))
+        return (void *) table->AllocDescriptorSets;
+    if (!strcmp(name, "ClearDescriptorSets"))
+        return (void *) table->ClearDescriptorSets;
+    if (!strcmp(name, "UpdateDescriptors"))
+        return (void *) table->UpdateDescriptors;
+    if (!strcmp(name, "CreateDynamicViewportState"))
+        return (void *) table->CreateDynamicViewportState;
+    if (!strcmp(name, "CreateDynamicRasterState"))
+        return (void *) table->CreateDynamicRasterState;
+    if (!strcmp(name, "CreateDynamicColorBlendState"))
+        return (void *) table->CreateDynamicColorBlendState;
+    if (!strcmp(name, "CreateDynamicDepthStencilState"))
+        return (void *) table->CreateDynamicDepthStencilState;
+    if (!strcmp(name, "CreateCommandBuffer"))
+        return (void *) table->CreateCommandBuffer;
+    if (!strcmp(name, "BeginCommandBuffer"))
+        return (void *) table->BeginCommandBuffer;
+    if (!strcmp(name, "EndCommandBuffer"))
+        return (void *) table->EndCommandBuffer;
+    if (!strcmp(name, "ResetCommandBuffer"))
+        return (void *) table->ResetCommandBuffer;
+    if (!strcmp(name, "CmdBindPipeline"))
+        return (void *) table->CmdBindPipeline;
+    if (!strcmp(name, "CmdBindDynamicStateObject"))
+        return (void *) table->CmdBindDynamicStateObject;
+    if (!strcmp(name, "CmdBindDescriptorSets"))
+        return (void *) table->CmdBindDescriptorSets;
+    if (!strcmp(name, "CmdBindVertexBuffers"))
+        return (void *) table->CmdBindVertexBuffers;
+    if (!strcmp(name, "CmdBindIndexBuffer"))
+        return (void *) table->CmdBindIndexBuffer;
+    if (!strcmp(name, "CmdDraw"))
+        return (void *) table->CmdDraw;
+    if (!strcmp(name, "CmdDrawIndexed"))
+        return (void *) table->CmdDrawIndexed;
+    if (!strcmp(name, "CmdDrawIndirect"))
+        return (void *) table->CmdDrawIndirect;
+    if (!strcmp(name, "CmdDrawIndexedIndirect"))
+        return (void *) table->CmdDrawIndexedIndirect;
+    if (!strcmp(name, "CmdDispatch"))
+        return (void *) table->CmdDispatch;
+    if (!strcmp(name, "CmdDispatchIndirect"))
+        return (void *) table->CmdDispatchIndirect;
+    if (!strcmp(name, "CmdCopyBuffer"))
+        return (void *) table->CmdCopyBuffer;
+    if (!strcmp(name, "CmdCopyImage"))
+        return (void *) table->CmdCopyImage;
+    if (!strcmp(name, "CmdBlitImage"))
+        return (void *) table->CmdBlitImage;
+    if (!strcmp(name, "CmdCopyBufferToImage"))
+        return (void *) table->CmdCopyBufferToImage;
+    if (!strcmp(name, "CmdCopyImageToBuffer"))
+        return (void *) table->CmdCopyImageToBuffer;
+    if (!strcmp(name, "CmdCloneImageData"))
+        return (void *) table->CmdCloneImageData;
+    if (!strcmp(name, "CmdUpdateBuffer"))
+        return (void *) table->CmdUpdateBuffer;
+    if (!strcmp(name, "CmdFillBuffer"))
+        return (void *) table->CmdFillBuffer;
+    if (!strcmp(name, "CmdClearColorImage"))
+        return (void *) table->CmdClearColorImage;
+    if (!strcmp(name, "CmdClearDepthStencil"))
+        return (void *) table->CmdClearDepthStencil;
+    if (!strcmp(name, "CmdResolveImage"))
+        return (void *) table->CmdResolveImage;
+    if (!strcmp(name, "CmdSetEvent"))
+        return (void *) table->CmdSetEvent;
+    if (!strcmp(name, "CmdResetEvent"))
+        return (void *) table->CmdResetEvent;
+    if (!strcmp(name, "CmdWaitEvents"))
+        return (void *) table->CmdWaitEvents;
+    if (!strcmp(name, "CmdPipelineBarrier"))
+        return (void *) table->CmdPipelineBarrier;
+    if (!strcmp(name, "CmdBeginQuery"))
+        return (void *) table->CmdBeginQuery;
+    if (!strcmp(name, "CmdEndQuery"))
+        return (void *) table->CmdEndQuery;
+    if (!strcmp(name, "CmdResetQueryPool"))
+        return (void *) table->CmdResetQueryPool;
+    if (!strcmp(name, "CmdWriteTimestamp"))
+        return (void *) table->CmdWriteTimestamp;
+    if (!strcmp(name, "CmdCopyQueryPoolResults"))
+        return (void *) table->CmdCopyQueryPoolResults;
+    if (!strcmp(name, "CmdInitAtomicCounters"))
+        return (void *) table->CmdInitAtomicCounters;
+    if (!strcmp(name, "CmdLoadAtomicCounters"))
+        return (void *) table->CmdLoadAtomicCounters;
+    if (!strcmp(name, "CmdSaveAtomicCounters"))
+        return (void *) table->CmdSaveAtomicCounters;
+    if (!strcmp(name, "CreateFramebuffer"))
+        return (void *) table->CreateFramebuffer;
+    if (!strcmp(name, "CreateRenderPass"))
+        return (void *) table->CreateRenderPass;
+    if (!strcmp(name, "CmdBeginRenderPass"))
+        return (void *) table->CmdBeginRenderPass;
+    if (!strcmp(name, "CmdEndRenderPass"))
+        return (void *) table->CmdEndRenderPass;
+    if (!strcmp(name, "DbgSetValidationLevel"))
+        return (void *) table->DbgSetValidationLevel;
+    if (!strcmp(name, "DbgRegisterMsgCallback"))
+        return (void *) table->DbgRegisterMsgCallback;
+    if (!strcmp(name, "DbgUnregisterMsgCallback"))
+        return (void *) table->DbgUnregisterMsgCallback;
+    if (!strcmp(name, "DbgSetMessageFilter"))
+        return (void *) table->DbgSetMessageFilter;
+    if (!strcmp(name, "DbgSetObjectTag"))
+        return (void *) table->DbgSetObjectTag;
+    if (!strcmp(name, "DbgSetGlobalOption"))
+        return (void *) table->DbgSetGlobalOption;
+    if (!strcmp(name, "DbgSetDeviceOption"))
+        return (void *) table->DbgSetDeviceOption;
+    if (!strcmp(name, "CmdDbgMarkerBegin"))
+        return (void *) table->CmdDbgMarkerBegin;
+    if (!strcmp(name, "CmdDbgMarkerEnd"))
+        return (void *) table->CmdDbgMarkerEnd;
+    if (!strcmp(name, "GetDisplayInfoWSI"))
+        return (void *) table->GetDisplayInfoWSI;
+    if (!strcmp(name, "CreateSwapChainWSI"))
+        return (void *) table->CreateSwapChainWSI;
+    if (!strcmp(name, "DestroySwapChainWSI"))
+        return (void *) table->DestroySwapChainWSI;
+    if (!strcmp(name, "GetSwapChainInfoWSI"))
+        return (void *) table->GetSwapChainInfoWSI;
+    if (!strcmp(name, "QueuePresentWSI"))
+        return (void *) table->QueuePresentWSI;
+
+    return NULL;
+}
diff --git a/loader/trampoline.c b/loader/trampoline.c
new file mode 100644
index 00000000..a435ca1f
--- /dev/null
+++ b/loader/trampoline.c
@@ -0,0 +1,1149 @@
+/*
+ * Vulkan
+ *
+ * Copyright (C) 2014 LunarG, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "loader.h"
+
+/* Trampoline entrypoints */
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceInfo(VkPhysicalDevice gpu, VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+    VkResult res;
+
+    disp = loader_get_dispatch(gpu);
+
+    res = disp->GetPhysicalDeviceInfo(gpu, infoType, pDataSize, pData);
+    if (infoType == VK_PHYSICAL_DEVICE_INFO_TYPE_DISPLAY_PROPERTIES_WSI && pData && res == VK_SUCCESS) {
+        VkDisplayPropertiesWSI *info = pData;
+        size_t count = *pDataSize / sizeof(*info), i;
+        for (i = 0; i < count; i++) {
+            loader_set_dispatch(info[i].display, disp);
+        }
+    }
+
+    return res;
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
+{
+    const VkLayerDispatchTable *disp;
+    VkResult res;
+
+    disp = loader_get_dispatch(gpu);
+
+    res = disp->CreateDevice(gpu, pCreateInfo, pDevice);
+    if (res == VK_SUCCESS) {
+        loader_init_dispatch(*pDevice, disp);
+    }
+
+    return res;
+}
+
+LOADER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyDevice(device);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(VkPhysicalDevice gpu, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(gpu);
+
+    return disp->GetPhysicalDeviceExtensionInfo(gpu, infoType, extensionIndex, pDataSize, pData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue)
+{
+    const VkLayerDispatchTable *disp;
+    VkResult res;
+
+    disp = loader_get_dispatch(device);
+
+    res = disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+    if (res == VK_SUCCESS) {
+        loader_set_dispatch(*pQueue, disp);
+    }
+
+    return res;
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueWaitIdle(queue);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DeviceWaitIdle(device);
+}
+
+LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->AllocMemory(device, pAllocInfo, pMem);
+}
+
+LOADER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->FreeMemory(device, mem);
+}
+
+LOADER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->SetMemoryPriority(device, mem, priority);
+}
+
+LOADER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->MapMemory(device, mem, offset, size, flags, ppData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->UnmapMemory(device, mem);
+}
+
+LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
+}
+
+LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
+}
+
+LOADER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->PinSystemMemory(device, pSysMem, memSize, pMem);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetMultiDeviceCompatibility(VkPhysicalDevice gpu0, VkPhysicalDevice gpu1, VkPhysicalDeviceCompatibilityInfo* pInfo)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(gpu0);
+
+    return disp->GetMultiDeviceCompatibility(gpu0, gpu1, pInfo);
+}
+
+LOADER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->OpenSharedMemory(device, pOpenInfo, pMem);
+}
+
+LOADER_EXPORT VkResult VKAPI vkOpenSharedSemaphore(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->OpenSharedSemaphore(device, pOpenInfo, pSemaphore);
+}
+
+LOADER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->OpenPeerMemory(device, pOpenInfo, pMem);
+}
+
+LOADER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->OpenPeerImage(device, pOpenInfo, pImage, pMem);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DestroyObject(device, objType, object);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetObjectInfo(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueBindObjectMemory(queue, objType, object, allocationIdx, mem, offset);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueBindImageMemoryRange(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueBindImageMemoryRange(queue, image, allocationIdx, pBindInfo, mem, memOffset);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateFence(device, pCreateInfo, pFence);
+}
+
+LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->ResetFences(device, fenceCount, pFences);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetFenceStatus(device, fence);
+}
+
+LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateSemaphore(device, pCreateInfo, pSemaphore);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueSignalSemaphore(queue, semaphore);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueueWaitSemaphore(queue, semaphore);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateEvent(device, pCreateInfo, pEvent);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetEventStatus(device, event);
+}
+
+LOADER_EXPORT VkResult VKAPI vkSetEvent(VkDevice device, VkEvent event)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->SetEvent(device, event);
+}
+
+LOADER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->ResetEvent(device, event);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateQueryPool(device, pCreateInfo, pQueryPool);
+}
+
+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;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetFormatInfo(device, format, infoType, pDataSize, pData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateBuffer(device, pCreateInfo, pBuffer);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateBufferView(device, pCreateInfo, pView);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateImage(device, pCreateInfo, pImage);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->GetImageSubresourceInfo(device, image, pSubresource, infoType, pDataSize, pData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateImageView(device, pCreateInfo, pView);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateColorAttachmentView(device, pCreateInfo, pView);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDepthStencilView(device, pCreateInfo, pView);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateShader(device, pCreateInfo, pShader);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateComputePipeline(device, pCreateInfo, pPipeline);
+}
+
+LOADER_EXPORT VkResult VKAPI vkStorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->StorePipeline(device, pipeline, pDataSize, pData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->LoadPipeline(device, dataSize, pData, pPipeline);
+}
+
+LOADER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateSampler(device, pCreateInfo, pSampler);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+}
+
+LOADER_EXPORT VkResult VKAPI vkBeginDescriptorPoolUpdate(VkDevice device, VkDescriptorUpdateMode updateMode)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->BeginDescriptorPoolUpdate(device, updateMode);
+}
+
+LOADER_EXPORT VkResult VKAPI vkEndDescriptorPoolUpdate(VkDevice device, VkCmdBuffer cmd)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->EndDescriptorPoolUpdate(device, cmd);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
+}
+
+LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->ResetDescriptorPool(device, descriptorPool);
+}
+
+LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount);
+}
+
+LOADER_EXPORT void VKAPI vkClearDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    disp->ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+}
+
+LOADER_EXPORT void VKAPI vkUpdateDescriptors(VkDevice device, VkDescriptorSet descriptorSet, uint32_t updateCount, const void** ppUpdateArray)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    disp->UpdateDescriptors(device, descriptorSet, updateCount, ppUpdateArray);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDynamicViewportState(device, pCreateInfo, pState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDynamicRasterState(device, pCreateInfo, pState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDynamicColorBlendState(device, pCreateInfo, pState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
+{
+    const VkLayerDispatchTable *disp;
+    VkResult res;
+
+    disp = loader_get_dispatch(device);
+
+    res = disp->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    if (res == VK_SUCCESS) {
+        loader_init_dispatch(*pCmdBuffer, disp);
+    }
+
+    return res;
+}
+
+LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    return disp->BeginCommandBuffer(cmdBuffer, pBeginInfo);
+}
+
+LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    return disp->EndCommandBuffer(cmdBuffer);
+}
+
+LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    return disp->ResetCommandBuffer(cmdBuffer);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+}
+
+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->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDispatch(cmdBuffer, x, y, z);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDispatchIndirect(cmdBuffer, buffer, offset);
+}
+
+LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+}
+
+LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+}
+
+LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+}
+
+LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+}
+
+LOADER_EXPORT void VKAPI vkCmdCloneImageData(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout);
+}
+
+LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+}
+
+LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
+}
+
+LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColor* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+}
+
+LOADER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+}
+
+LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+}
+
+LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdSetEvent(cmdBuffer, event, pipeEvent);
+}
+
+LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdResetEvent(cmdBuffer, event, pipeEvent);
+}
+
+LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers);
+}
+
+LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+}
+
+LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdEndQuery(cmdBuffer, queryPool, slot);
+}
+
+LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+}
+
+LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
+}
+
+LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkFlags flags)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
+}
+
+LOADER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData);
+}
+
+LOADER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset);
+}
+
+LOADER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkDeviceSize destOffset)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset);
+}
+
+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 vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
+}
+
+LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin);
+}
+
+LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdEndRenderPass(cmdBuffer, renderPass);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDbgSetValidationLevel(VkDevice device, VkValidationLevel validationLevel)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DbgSetValidationLevel(device, validationLevel);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DbgSetMessageFilter(device, msgCode, filter);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkDevice device, VkObject object, size_t tagSize, const void* pTag)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DbgSetObjectTag(device, object, tagSize, pTag);
+}
+
+LOADER_EXPORT VkResult VKAPI vkDbgSetDeviceOption(VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(device);
+
+    return disp->DbgSetDeviceOption(device, dbgOption, dataSize, pData);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDbgMarkerBegin(cmdBuffer, pMarker);
+}
+
+LOADER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(cmdBuffer);
+
+    disp->CmdDbgMarkerEnd(cmdBuffer);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetDisplayInfoWSI(VkDisplayWSI display, VkDisplayInfoTypeWSI infoType, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(display);
+
+    return disp->GetDisplayInfoWSI(display, infoType, pDataSize, pData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain)
+{
+    const VkLayerDispatchTable *disp;
+    VkResult res;
+
+    disp = loader_get_dispatch(device);
+
+    res = disp->CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
+    if (res == VK_SUCCESS) {
+        loader_init_dispatch(*pSwapChain, disp);
+    }
+
+    return res;
+}
+
+LOADER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(VkSwapChainWSI swapChain)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(swapChain);
+
+    return disp->DestroySwapChainWSI(swapChain);
+}
+
+LOADER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(swapChain);
+
+    return disp->GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
+}
+
+LOADER_EXPORT VkResult VKAPI vkQueuePresentWSI(VkQueue queue, const VkPresentInfoWSI* pPresentInfo)
+{
+    const VkLayerDispatchTable *disp;
+
+    disp = loader_get_dispatch(queue);
+
+    return disp->QueuePresentWSI(queue, pPresentInfo);
+}
diff --git a/loader/vulkan.def b/loader/vulkan.def
new file mode 100644
index 00000000..2be6ed6d
--- /dev/null
+++ b/loader/vulkan.def
@@ -0,0 +1,158 @@
+;;;; Begin Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; Vulkan
+;
+; Copyright (C) 2015 LunarG, Inc.
+;
+; Permission is hereby granted, free of charge, to any person obtaining a
+; copy of this software and associated documentation files (the "Software"),
+; to deal in the Software without restriction, including without limitation
+; the rights to use, copy, modify, merge, publish, distribute, sublicense,
+; and/or sell copies of the Software, and to permit persons to whom the
+; Software is furnished to do so, subject to the following conditions:
+;
+; The above copyright notice and this permission notice shall be included
+; in all copies or substantial portions of the Software.
+;
+; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+; THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+; DEALINGS IN THE SOFTWARE.
+;;;;  End Copyright Notice ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; The following is required on Windows, for exporting symbols from the DLL
+
+LIBRARY vulkan
+EXPORTS
+   vkCreateInstance
+   vkDestroyInstance
+   vkEnumeratePhysicalDevices
+   vkGetPhysicalDeviceInfo
+   vkGetProcAddr
+   vkCreateDevice
+   vkDestroyDevice
+   vkGetGlobalExtensionInfo
+   vkGetPhysicalDeviceExtensionInfo
+   vkEnumerateLayers
+   vkGetDeviceQueue
+   vkQueueSubmit
+   vkQueueWaitIdle
+   vkDeviceWaitIdle
+   vkAllocMemory
+   vkFreeMemory
+   vkSetMemoryPriority
+   vkMapMemory
+   vkUnmapMemory
+   vkFlushMappedMemoryRanges
+   vkInvalidateMappedMemoryRanges
+   vkPinSystemMemory
+   vkGetMultiDeviceCompatibility
+   vkOpenSharedMemory
+   vkOpenSharedSemaphore
+   vkOpenPeerMemory
+   vkOpenPeerImage
+   vkDestroyObject
+   vkGetObjectInfo
+   vkQueueBindObjectMemory
+   vkQueueBindObjectMemoryRange
+   vkQueueBindImageMemoryRange
+   vkCreateFence
+   vkResetFences
+   vkGetFenceStatus
+   vkWaitForFences
+   vkCreateSemaphore
+   vkQueueSignalSemaphore
+   vkQueueWaitSemaphore
+   vkCreateEvent
+   vkGetEventStatus
+   vkSetEvent
+   vkResetEvent
+   vkCreateQueryPool
+   vkGetQueryPoolResults
+   vkGetFormatInfo
+   vkCreateBuffer
+   vkCreateBufferView
+   vkCreateImage
+   vkGetImageSubresourceInfo
+   vkCreateImageView
+   vkCreateColorAttachmentView
+   vkCreateDepthStencilView
+   vkCreateShader
+   vkCreateGraphicsPipeline
+   vkCreateGraphicsPipelineDerivative
+   vkCreateComputePipeline
+   vkStorePipeline
+   vkLoadPipeline
+   vkLoadPipelineDerivative
+   vkCreatePipelineLayout
+   vkCreateSampler
+   vkCreateDescriptorSetLayout
+   vkBeginDescriptorPoolUpdate
+   vkEndDescriptorPoolUpdate
+   vkCreateDescriptorPool
+   vkResetDescriptorPool
+   vkAllocDescriptorSets
+   vkClearDescriptorSets
+   vkUpdateDescriptors
+   vkCreateDynamicViewportState
+   vkCreateDynamicRasterState
+   vkCreateDynamicColorBlendState
+   vkCreateDynamicDepthStencilState
+   vkCreateCommandBuffer
+   vkBeginCommandBuffer
+   vkEndCommandBuffer
+   vkResetCommandBuffer
+   vkCmdBindPipeline
+   vkCmdBindDynamicStateObject
+   vkCmdBindDescriptorSets
+   vkCmdBindVertexBuffers
+   vkCmdBindIndexBuffer
+   vkCmdDraw
+   vkCmdDrawIndexed
+   vkCmdDrawIndirect
+   vkCmdDrawIndexedIndirect
+   vkCmdDispatch
+   vkCmdDispatchIndirect
+   vkCmdCopyBuffer
+   vkCmdCopyImage
+   vkCmdBlitImage
+   vkCmdCopyBufferToImage
+   vkCmdCopyImageToBuffer
+   vkCmdCloneImageData
+   vkCmdUpdateBuffer
+   vkCmdFillBuffer
+   vkCmdClearColorImage
+   vkCmdClearDepthStencil
+   vkCmdResolveImage
+   vkCmdSetEvent
+   vkCmdResetEvent
+   vkCmdWaitEvents
+   vkCmdPipelineBarrier
+   vkCmdBeginQuery
+   vkCmdEndQuery
+   vkCmdResetQueryPool
+   vkCmdWriteTimestamp
+   vkCmdCopyQueryPoolResults
+   vkCmdInitAtomicCounters
+   vkCmdLoadAtomicCounters
+   vkCmdSaveAtomicCounters
+   vkCreateFramebuffer
+   vkCreateRenderPass
+   vkCmdBeginRenderPass
+   vkCmdEndRenderPass
+   vkDbgSetValidationLevel
+   vkDbgRegisterMsgCallback
+   vkDbgUnregisterMsgCallback
+   vkDbgSetMessageFilter
+   vkDbgSetObjectTag
+   vkDbgSetGlobalOption
+   vkDbgSetDeviceOption
+   vkCmdDbgMarkerBegin
+   vkCmdDbgMarkerEnd
+   vkGetDisplayInfoWSI
+   vkCreateSwapChainWSI
+   vkDestroySwapChainWSI
+   vkGetSwapChainInfoWSI
+   vkQueuePresentWSI