diff --git a/include/vkLayer.h b/include/vkLayer.h
index 9edf326..f30ef25 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -26,7 +26,7 @@
 
 typedef struct VkLayerDispatchTable_
 {
-    PFN_vkGetProcAddr GetProcAddr;
+    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
     PFN_vkDestroyDevice DestroyDevice;
     PFN_vkGetDeviceQueue GetDeviceQueue;
     PFN_vkQueueSubmit QueueSubmit;
@@ -145,7 +145,6 @@
 typedef struct VkLayerInstanceDispatchTable_
 {
     PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
-    PFN_vkGetProcAddr GetProcAddr;  // TODO remove once GPA takes device parameter
     PFN_vkCreateInstance CreateInstance;
     PFN_vkDestroyInstance DestroyInstance;
     PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
diff --git a/include/vulkan.h b/include/vulkan.h
index b8bd81e..89431af 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -2088,7 +2088,7 @@
 typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceInfo)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceInfoType infoType, size_t* pDataSize, void* pData);
 typedef void *   (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char * pName);
-typedef void *   (VKAPI *PFN_vkGetProcAddr)(VkPhysicalDevice physicalDevice, const char * pName);
+typedef void *   (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char * pName);
 typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
 typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
 typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionInfo)(VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData);
@@ -2224,8 +2224,8 @@
     VkInstance                                  instance,
     const char*                                 pName);
 
-void * VKAPI vkGetProcAddr(
-    VkPhysicalDevice                            physicalDevice,
+void * VKAPI vkGetDeviceProcAddr(
+    VkDevice                                    device,
     const char*                                 pName);
 // Device functions
 
diff --git a/layers/basic.cpp b/layers/basic.cpp
index 00adfa6..0d24876 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -79,7 +79,7 @@
         return it->second;
     }
 
-    layer_initialize_dispatch_table(pTable, (PFN_vkGetProcAddr) devw->pGPA, (VkPhysicalDevice) devw->nextObject);
+    layer_initialize_dispatch_table(pTable, (PFN_vkGetDeviceProcAddr) devw->pGPA, (VkDevice) devw->nextObject);
 
     return pTable;
 }
@@ -210,32 +210,24 @@
     }
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
 {
-    if (gpu == NULL)
+    if (device == NULL)
         return NULL;
 
-    initLayerTable((const VkBaseLayerObject *) gpu);
+    initLayerTable((const VkBaseLayerObject *) device);
 
-    if (!strcmp("vkGetProcAddr", pName))
-        return (void *) vkGetProcAddr;
-    if (!strcmp("vkCreateDevice", pName))
-        return (void *) vkCreateDevice;
-    if (!strcmp("vkEnumeratePhysicalDevices", pName))
-        return (void*) vkEnumeratePhysicalDevices;
-    if (!strcmp("vkGetGlobalExtensionInfo", pName))
-        return (void*) vkGetGlobalExtensionInfo;
-    if (!strcmp("vkEnumerateLayers", pName))
-        return (void *) vkEnumerateLayers;
+    if (!strcmp("vkGetDeviceProcAddr", pName))
+        return (void *) vkGetDeviceProcAddr;
     if (!strcmp("vkGetFormatInfo", pName))
         return (void *) vkGetFormatInfo;
     if (!strcmp("vkLayerExtension1", pName))
         return (void *) vkLayerExtension1;
     else {
-        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
-        if (gpuw->pGPA == NULL)
+        VkBaseLayerObject* devw = (VkBaseLayerObject *) device;
+        if (devw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((VkObject) gpuw->nextObject, pName);
+        return devw->pGPA((VkObject) devw->nextObject, pName);
     }
 }
 
@@ -248,8 +240,6 @@
 
     if (!strcmp("vkGetInstanceProcAddr", pName))
         return (void *) vkGetInstanceProcAddr;
-    if (!strcmp("vkGetProcAddr", pName))
-        return (void *) vkGetProcAddr;
     if (!strcmp("vkEnumeratePhysicalDevices", pName))
         return (void*) vkEnumeratePhysicalDevices;
     if (!strcmp("vkGetGlobalExtensionInfo", pName))
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index e803940..781dbc3 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1445,10 +1445,10 @@
 // TODO handle multiple GPUs/instances for both instance and device dispatch tables
 static void initDeviceTable(void)
 {
-    PFN_vkGetProcAddr fpNextGPA;
-    fpNextGPA = (PFN_vkGetProcAddr) pCurObj->pGPA;
+    PFN_vkGetDeviceProcAddr fpNextGPA;
+    fpNextGPA = (PFN_vkGetDeviceProcAddr) pCurObj->pGPA;
     assert(fpNextGPA);
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalDevice) pCurObj->nextObject);
+    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkDevice) pCurObj->nextObject);
 }
 
 static void initInstanceTable(void)
@@ -2736,24 +2736,20 @@
 #endif // WIN32
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* funcName)
+VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
 {
-    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkBaseLayerObject* devw = (VkBaseLayerObject *) dev;
 
-    if (gpu == NULL)
+    if (dev == NULL)
         return NULL;
-    pCurObj = gpuw;
+    pCurObj = devw;
     loader_platform_thread_once(&g_initOnce, initDrawState);
     loader_platform_thread_once(&g_tabDeviceOnce, initDeviceTable);
 
-    if (!strcmp(funcName, "vkGetProcAddr"))
-        return (void *) vkGetProcAddr;
-    if (!strcmp(funcName, "vkCreateDevice"))
-        return (void*) vkCreateDevice;
+    if (!strcmp(funcName, "vkGetDeviceProcAddr"))
+        return (void *) vkGetDeviceProcAddr;
     if (!strcmp(funcName, "vkDestroyDevice"))
         return (void*) vkDestroyDevice;
-    if (!strcmp(funcName, "vkEnumerateLayers"))
-        return (void*) vkEnumerateLayers;
     if (!strcmp(funcName, "vkQueueSubmit"))
         return (void*) vkQueueSubmit;
     if (!strcmp(funcName, "vkDestroyObject"))
@@ -2868,10 +2864,6 @@
         return (void*) vkCmdBeginRenderPass;
     if (!strcmp(funcName, "vkCmdEndRenderPass"))
         return (void*) vkCmdEndRenderPass;
-    if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
-        return (void*) vkDbgRegisterMsgCallback;
-    if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
-        return (void*) vkDbgUnregisterMsgCallback;
     if (!strcmp(funcName, "vkCmdDbgMarkerBegin"))
         return (void*) vkCmdDbgMarkerBegin;
     if (!strcmp(funcName, "vkCmdDbgMarkerEnd"))
@@ -2883,9 +2875,9 @@
     if (!strcmp("drawStateDumpPngFile", funcName))
         return (void*) drawStateDumpPngFile;
     else {
-        if (gpuw->pGPA == NULL)
+        if (devw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((VkObject)gpuw->nextObject, funcName);
+        return devw->pGPA((VkObject)devw->nextObject, funcName);
     }
 }
 
@@ -2901,8 +2893,6 @@
 
     if (!strcmp(funcName, "vkGetInstanceProcAddr"))
         return (void *) vkGetInstanceProcAddr;
-    if (!strcmp(funcName, "vkGetProcAddr"))
-        return (void *) vkGetProcAddr;
     if (!strcmp(funcName, "vkCreateDevice"))
         return (void*) vkCreateDevice;
     if (!strcmp(funcName, "vkEnumerateLayers"))
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 5ab3bca..f04ab63 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -778,10 +778,10 @@
 // TODO handle multiple GPUs/instances for both instance and device dispatch tables
 static void initDeviceTable(void)
 {
-    PFN_vkGetProcAddr fpNextGPA;
-    fpNextGPA = (PFN_vkGetProcAddr) pCurObj->pGPA;
+    PFN_vkGetDeviceProcAddr fpNextGPA;
+    fpNextGPA = (PFN_vkGetDeviceProcAddr) pCurObj->pGPA;
     assert(fpNextGPA);
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalDevice) pCurObj->nextObject);
+    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkDevice) pCurObj->nextObject);
 }
 
 static void initInstanceTable(void)
@@ -2150,29 +2150,23 @@
     return result;
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(
-    VkPhysicalDevice  gpu,
+VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(
+    VkDevice         dev,
     const char       *funcName)
 {
-    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkBaseLayerObject* devw = (VkBaseLayerObject *) dev;
 
-    if (gpu == NULL) {
+    if (dev == NULL) {
         return NULL;
     }
-    pCurObj = gpuw;
+    pCurObj = devw;
     loader_platform_thread_once(&g_initOnce, initMemTracker);
     loader_platform_thread_once(&g_tabDeviceOnce, initDeviceTable);
 
-    if (!strcmp(funcName, "vkGetProcAddr"))
-        return (void *) vkGetProcAddr;
-    if (!strcmp(funcName, "vkCreateDevice"))
-        return (void*) vkCreateDevice;
+    if (!strcmp(funcName, "vkGetDeviceProcAddr"))
+        return (void *) vkGetDeviceProcAddr;
     if (!strcmp(funcName, "vkDestroyDevice"))
         return (void*) vkDestroyDevice;
-    if (!strcmp(funcName, "GetGlobalExtensionInfo"))
-        return (void*) vkGetGlobalExtensionInfo;
-    if (!strcmp(funcName, "vkEnumerateLayers"))
-        return (void*) vkEnumerateLayers;
     if (!strcmp(funcName, "vkQueueSubmit"))
         return (void*) vkQueueSubmit;
     if (!strcmp(funcName, "vkAllocMemory"))
@@ -2295,10 +2289,6 @@
         return (void*) vkCmdEndQuery;
     if (!strcmp(funcName, "vkCmdResetQueryPool"))
         return (void*) vkCmdResetQueryPool;
-    if (!strcmp(funcName, "vkDbgRegisterMsgCallback"))
-        return (void*) vkDbgRegisterMsgCallback;
-    if (!strcmp(funcName, "vkDbgUnregisterMsgCallback"))
-        return (void*) vkDbgUnregisterMsgCallback;
     if (!strcmp(funcName, "vkGetDeviceQueue"))
         return (void*) vkGetDeviceQueue;
     if (!strcmp(funcName, "vkCreateSwapChainWSI"))
@@ -2308,10 +2298,10 @@
     if (!strcmp(funcName, "vkGetSwapChainInfoWSI"))
         return (void*) vkGetSwapChainInfoWSI;
     else {
-        if (gpuw->pGPA == NULL) {
+        if (devw->pGPA == NULL) {
             return NULL;
         }
-        return gpuw->pGPA((VkObject)gpuw->nextObject, funcName);
+        return devw->pGPA((VkObject)devw->nextObject, funcName);
     }
 }
 
@@ -2329,8 +2319,6 @@
     loader_platform_thread_once(&g_initOnce, initMemTracker);
     loader_platform_thread_once(&g_tabInstanceOnce, initInstanceTable);
 
-    if (!strcmp(funcName, "vkGetProcAddr"))
-        return (void *) vkGetProcAddr;
     if (!strcmp(funcName, "vkGetInstanceProcAddr"))
         return (void *) vkGetInstanceProcAddr;
     if (!strcmp(funcName, "vkCreateDevice"))
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 90f7b90..1d6764b 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -34,7 +34,7 @@
 // being used:
 #include "loader_platform.h"
 
-static void initLayerTable(const VkBaseLayerObject *gpuw, VkLayerDispatchTable *pTable, const unsigned int layerNum);
+static void initLayerTable(const VkBaseLayerObject *devw, VkLayerDispatchTable *pTable, const unsigned int layerNum);
 static void initLayerInstanceTable(const VkBaseLayerObject *instw, VkLayerInstanceDispatchTable *pTable, const unsigned int layerNum);
 /* Various dispatchable objects will use the same underlying dispatch table if they
  * are created from that "parent" object. Thus use pointer to dispatch table
@@ -136,29 +136,25 @@
     return result;
 }
 
-VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VkPhysicalDevice gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI multi1GetDeviceProcAddr(VkDevice device, const char* pName)
 {
-    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkBaseLayerObject* devw = (VkBaseLayerObject *) device;
 
-    if (gpu == NULL)
+    if (device == NULL)
         return NULL;
 
-    getLayer1Table(gpuw);
+    getLayer1Table(devw);
 
     if (!strcmp("vkCreateSampler", pName))
         return (void *) multi1CreateSampler;
-    if (!strcmp("vkEnumerateLayers", pName))
-        return (void *) multi1EnumerateLayers;
-    else if (!strcmp("GetGlobalExtensionInfo", pName))
-        return (void*) vkGetGlobalExtensionInfo;
     else if (!strcmp("vkCreateGraphicsPipeline", pName))
         return (void *) multi1CreateGraphicsPipeline;
     else if (!strcmp("vkStorePipeline", pName))
         return (void *) multi1StorePipeline;
     else {
-        if (gpuw->pGPA == NULL)
+        if (devw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((VkObject) gpuw->nextObject, pName);
+        return devw->pGPA((VkObject) devw->nextObject, pName);
     }
 }
 
@@ -171,8 +167,6 @@
 
     getLayer1InstanceTable(instw);
 
-    if (!strcmp("vkCreateSampler", pName))
-        return (void *) multi1CreateSampler;
     if (!strcmp("vkEnumerateLayers", pName))
         return (void *) multi1EnumerateLayers;
     else if (!strcmp("GetGlobalExtensionInfo", pName))
@@ -292,31 +286,23 @@
     return result;
 }
 
-VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VkPhysicalDevice gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI multi2GetDeviceProcAddr(VkDevice device, const char* pName)
 {
-    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkBaseLayerObject* devw = (VkBaseLayerObject *) device;
 
-    if (gpu == NULL)
+    if (device == NULL)
         return NULL;
 
-    getLayer2Table(gpuw);
+    getLayer2Table(devw);
 
-    if (!strcmp("vkEnumeratePhysicalDevices", pName))
-        return (void *) multi2EnumeratePhysicalDevices;
-    if (!strcmp("vkCreateDevice", pName))
-        return (void *) multi2CreateDevice;
-    else if (!strcmp("vkEnumerateLayers", pName))
-        return (void *) multi2EnumerateLayers;
-    else if (!strcmp("GetGlobalExtensionInfo", pName))
-        return (void*) vkGetGlobalExtensionInfo;
-    else if (!strcmp("vkCreateCommandBuffer", pName))
+    if (!strcmp("vkCreateCommandBuffer", pName))
         return (void *) multi2CreateCommandBuffer;
     else if (!strcmp("vkBeginCommandBuffer", pName))
         return (void *) multi2BeginCommandBuffer;
     else {
-        if (gpuw->pGPA == NULL)
+        if (devw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((VkObject) gpuw->nextObject, pName);
+        return devw->pGPA((VkObject) devw->nextObject, pName);
     }
 }
 
@@ -412,21 +398,21 @@
     return VK_SUCCESS;
 }
 
-VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
 {
-    // to find each layers GPA routine Loader will search via "<layerName>GetProcAddr"
-    if (!strcmp("multi1GetProcAddr", pName))
-        return (void *) multi1GetProcAddr;
-    else if (!strcmp("multi2GetProcAddr", pName))
-        return (void *) multi2GetProcAddr;
-    else if (!strcmp("vkGetProcAddr", pName))
-        return (void *) vkGetProcAddr;
+    // to find each layers GPA routine Loader will search via "<layerName>GetDeviceProcAddr"
+    if (!strcmp("multi1GetDeviceProcAddr", pName))
+        return (void *) multi1GetDeviceProcAddr;
+    else if (!strcmp("multi2GetDeviceProcAddr", pName))
+        return (void *) multi2GetDeviceProcAddr;
+    else if (!strcmp("vkGetDeviceProcAddr", pName))
+        return (void *) vkGetDeviceProcAddr;
 
     // use first layer activated as GPA dispatch table activation happens in order
     else if (layer1_first_activated)
-        return multi1GetProcAddr(gpu, pName);
+        return multi1GetDeviceProcAddr(device, pName);
     else if (layer2_first_activated)
-        return multi2GetProcAddr(gpu, pName);
+        return multi2GetDeviceProcAddr(device, pName);
     else
         return NULL;
 
@@ -434,19 +420,13 @@
 
 VK_LAYER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance inst, const char* pName)
 {
-    // to find each layers GPA routine Loader will search via "<layerName>GetProcAddr"
-    if (!strcmp("multi1GetProcAddr", pName))
-        return (void *) multi1GetProcAddr;
-    else if (!strcmp("multi2GetProcAddr", pName))
-        return (void *) multi2GetProcAddr;
-    else if (!strcmp("vkGetProcAddr", pName))
-        return (void *) vkGetProcAddr;
-    else if (!strcmp("multi1GetInstanceProcAddr", pName))
+    // to find each layers GPA routine Loader will search via "<layerName>GetInstanceProcAddr"
+    if (!strcmp("multi1GetInstanceProcAddr", pName))
         return (void *) multi1GetInstanceProcAddr;
     else if (!strcmp("multi2GetInstanceProcAddr", pName))
         return (void *) multi2GetInstanceProcAddr;
     else if (!strcmp("vkGetInstanceProcAddr", pName))
-        return (void *) vkGetProcAddr;
+        return (void *) vkGetInstanceProcAddr;
 
     // use first layer activated as GPA dispatch table activation happens in order
     else if (layer1_first_activated)
@@ -461,14 +441,14 @@
 }    //extern "C"
 #endif
 
-static void initLayerTable(const VkBaseLayerObject *gpuw, VkLayerDispatchTable *pTable, const unsigned int layerNum)
+static void initLayerTable(const VkBaseLayerObject *devw, VkLayerDispatchTable *pTable, const unsigned int layerNum)
 {
     if (layerNum == 2 && layer1_first_activated == false)
         layer2_first_activated = true;
     if (layerNum == 1 && layer2_first_activated == false)
         layer1_first_activated = true;
 
-    layer_initialize_dispatch_table(pTable, (PFN_vkGetProcAddr) gpuw->pGPA, (VkPhysicalDevice) gpuw->nextObject);
+    layer_initialize_dispatch_table(pTable, (PFN_vkGetDeviceProcAddr) devw->pGPA, (VkDevice) devw->nextObject);
 }
 
 static void initLayerInstanceTable(const VkBaseLayerObject *instw, VkLayerInstanceDispatchTable *pTable, const unsigned int layerNum)
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 434f87d..8fdcb8d 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -52,10 +52,10 @@
 // TODO handle multiple GPUs/instances for both instance and device dispatch tables
 static void initDeviceTable(void)
 {
-    PFN_vkGetProcAddr fpNextGPA;
-    fpNextGPA = (PFN_vkGetProcAddr) pCurObj->pGPA;
+    PFN_vkGetDeviceProcAddr fpNextGPA;
+    fpNextGPA = (PFN_vkGetDeviceProcAddr) pCurObj->pGPA;
     assert(fpNextGPA);
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalDevice) pCurObj->nextObject);
+    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkDevice) pCurObj->nextObject);
 }
 
 static void initInstanceTable(void)
@@ -1970,24 +1970,10 @@
         return NULL;
 
     name += 2;
-    if (!strcmp(name, "CreateInstance"))
-        return (void*) vkCreateInstance;
-    if (!strcmp(name, "DestroyInstance"))
-        return (void*) vkDestroyInstance;
-    if (!strcmp(name, "GetPhysicalDeviceInfo"))
-        return (void*) vkGetPhysicalDeviceInfo;
-    if (!strcmp(name, "GetProcAddr"))
-        return (void*) vkGetProcAddr;
-    if (!strcmp(name, "CreateDevice"))
-        return (void*) vkCreateDevice;
+    if (!strcmp(name, "GetDeviceProcAddr"))
+        return (void*) vkGetDeviceProcAddr;
     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"))
@@ -2012,8 +1998,6 @@
         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"))
@@ -2188,16 +2172,10 @@
         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"))
@@ -2232,8 +2210,6 @@
         return (void*) vkDestroyInstance;
     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"))
@@ -2254,13 +2230,13 @@
     return NULL;
 }
 
-VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* funcName)
+VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
 {
-    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkBaseLayerObject* devw = (VkBaseLayerObject *) device;
     void* addr;
-    if (gpu == NULL)
+    if (device == NULL)
         return NULL;
-    pCurObj = gpuw;
+    pCurObj = devw;
     loader_platform_thread_once(&initOnce, initParamChecker);
     loader_platform_thread_once(&tabDeviceOnce, initDeviceTable);
 
@@ -2268,9 +2244,9 @@
     if (addr)
         return addr;
     else {
-        if (gpuw->pGPA == NULL)
+        if (devw->pGPA == NULL)
             return NULL;
-        return gpuw->pGPA((VkObject)gpuw->nextObject, funcName);
+        return devw->pGPA((VkObject)devw->nextObject, funcName);
     }
 }
 
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index fd3a815..23c6740 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -145,22 +145,22 @@
 }
 
 
-static VkLayerDispatchTable * initLayerTable(const VkBaseLayerObject *gpuw)
+static VkLayerDispatchTable * initLayerTable(const VkBaseLayerObject *devw)
 {
     VkLayerDispatchTable *pTable;
 
-    assert(gpuw);
-    std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap.find((void *) gpuw->baseObject);
+    assert(devw);
+    std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap.find((void *) devw->baseObject);
     if (it == tableMap.end())
     {
         pTable =  new VkLayerDispatchTable;
-        tableMap[(void *) gpuw->baseObject] = pTable;
+        tableMap[(void *) devw->baseObject] = pTable;
     } else
     {
         return it->second;
     }
 
-    layer_initialize_dispatch_table(pTable, (PFN_vkGetProcAddr) gpuw->pGPA, (VkPhysicalDevice) gpuw->nextObject);
+    layer_initialize_dispatch_table(pTable, (PFN_vkGetDeviceProcAddr) devw->pGPA, (VkDevice) devw->nextObject);
 
     return pTable;
 }
@@ -1002,12 +1002,12 @@
 }
 
 
-VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* pName)
+VK_LAYER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice device, const char* pName)
 {
-    if (gpu == NULL)
+    if (device == NULL)
         return NULL;
 
-    initLayerTable((const VkBaseLayerObject *) gpu);
+    initLayerTable((const VkBaseLayerObject *) device);
 
     loader_platform_thread_once(&g_initOnce, initLayer);
 
@@ -1015,18 +1015,16 @@
     if (!strncmp(#fn, pName, sizeof(#fn))) \
         return (void *) fn
 
-    ADD_HOOK(vkGetProcAddr);
-    ADD_HOOK(vkEnumerateLayers);
-    ADD_HOOK(vkGetGlobalExtensionInfo);
+    ADD_HOOK(vkGetDeviceProcAddr);
     ADD_HOOK(vkCreateShader);
     ADD_HOOK(vkCreateGraphicsPipeline);
     ADD_HOOK(vkCreateGraphicsPipelineDerivative);
 #undef ADD_HOOK
 
-    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
-    if (gpuw->pGPA == NULL)
+    VkBaseLayerObject* devw = (VkBaseLayerObject *) device;
+    if (devw->pGPA == NULL)
         return NULL;
-    return gpuw->pGPA((VkObject) gpuw->nextObject, pName);
+    return devw->pGPA((VkObject) devw->nextObject, pName);
 }
 
 VK_LAYER_EXPORT void * VKAPI vkGetInstanceProcAddr(VkInstance inst, const char* pName)
@@ -1042,7 +1040,6 @@
     if (!strncmp(#fn, pName, sizeof(#fn))) \
         return (void *) fn
 
-    ADD_HOOK(vkGetProcAddr);
     ADD_HOOK(vkGetInstanceProcAddr);
     ADD_HOOK(vkEnumerateLayers);
     ADD_HOOK(vkGetGlobalExtensionInfo);
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index eb8d1fb..3e49195 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -40,8 +40,8 @@
         return (void*) vkGetPhysicalDeviceInfo;
     if (!strcmp(name, "GetInstanceProcAddr"))
         return (void*) vkGetInstanceProcAddr;
-    if (!strcmp(name, "GetProcAddr"))
-        return (void*) vkGetProcAddr;
+    if (!strcmp(name, "GetDeviceProcAddr"))
+        return (void*) vkGetDeviceProcAddr;
     if (!strcmp(name, "CreateDevice"))
         return (void*) vkCreateDevice;
     if (!strcmp(name, "DestroyDevice"))
@@ -310,8 +310,8 @@
         return (void*) vkGetPhysicalDeviceInfo;
     if (!strcmp(name, "GetInstanceProcAddr"))
         return (void*) vkGetInstanceProcAddr;
-    if (!strcmp(name, "GetProcAddr"))
-        return (void*) vkGetProcAddr;
+    if (!strcmp(name, "GetDeviceProcAddr"))
+        return (void*) vkGetDeviceProcAddr;
     if (!strcmp(name, "CreateDevice"))
         return (void*) vkCreateDevice;
     if (!strcmp(name, "GetGlobalExtensionInfo"))
diff --git a/loader/loader.c b/loader/loader.c
index 37fea21..737bf66 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -74,7 +74,6 @@
 
 VkLayerInstanceDispatchTable instance_disp = {
     .GetInstanceProcAddr = vkGetInstanceProcAddr,
-    .GetProcAddr = vkGetProcAddr,
     .CreateInstance = loader_CreateInstance,
     .DestroyInstance = loader_DestroyInstance,
     .EnumeratePhysicalDevices = loader_EnumeratePhysicalDevices,
@@ -462,8 +461,8 @@
     }                                                          \
     } while (0)
 
-    /* could change this to use GetInstanceProcAddr in driver once they support it */
-    LOOKUP(GetProcAddr);
+    /* could change this to use GetInstanceProcAddr in driver instead of dlsym */
+    LOOKUP(GetDeviceProcAddr);
     LOOKUP(DestroyInstance);
     LOOKUP(EnumeratePhysicalDevices);
     LOOKUP(GetPhysicalDeviceInfo);
@@ -738,9 +737,9 @@
     if (addr)
         return addr;
     else  {
-        if (disp_table->GetProcAddr == NULL)
+        if (disp_table->GetDeviceProcAddr == NULL)
             return NULL;
-        return disp_table->GetProcAddr(physDev, pName);
+        return disp_table->GetDeviceProcAddr(physDev, pName);
     }
 }
 
@@ -1135,7 +1134,7 @@
         VkObject nextObj =  (VkObject) device;
         VkObject baseObj = nextObj;
         VkBaseLayerObject *nextGpuObj;
-        PFN_vkGetProcAddr nextGPA = loader_gpa_device_internal;
+        PFN_vkGetDeviceProcAddr nextGPA = loader_gpa_device_internal;
 
         count = loader_get_layer_libs(ext_count, ext_names, &pLayerNames);
         if (!count)
@@ -1155,11 +1154,11 @@
             nextObj = (VkObject) nextGpuObj;
 
             char funcStr[256];
-            snprintf(funcStr, 256, "%sGetProcAddr",icd->layer_libs[gpu_index][i].name);
-            if ((nextGPA = (PFN_vkGetProcAddr) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, funcStr)) == NULL)
-                nextGPA = (PFN_vkGetProcAddr) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, "vkGetProcAddr");
+            snprintf(funcStr, 256, "%sGetDeviceProcAddr",icd->layer_libs[gpu_index][i].name);
+            if ((nextGPA = (PFN_vkGetDeviceProcAddr) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, funcStr)) == NULL)
+                nextGPA = (PFN_vkGetDeviceProcAddr) loader_platform_get_proc_address(icd->layer_libs[gpu_index][i].lib_handle, "vkGetDeviceProcAddr");
             if (!nextGPA) {
-                loader_log(VK_DBG_MSG_ERROR, 0, "Failed to find vkGetProcAddr in layer %s", icd->layer_libs[gpu_index][i].name);
+                loader_log(VK_DBG_MSG_ERROR, 0, "Failed to find vkGetDeviceProcAddr in layer %s", icd->layer_libs[gpu_index][i].name);
                 continue;
             }
 
@@ -1168,7 +1167,7 @@
                 //Insert the new wrapped objects into the list with loader object at head
                 nextGpuObj = icd->wrappedGpus[gpu_index] + icd->layer_count[gpu_index] - 1;
                 nextGpuObj->nextObject = baseObj;
-                nextGpuObj->pGPA = icd->GetProcAddr;
+                nextGpuObj->pGPA = icd->GetDeviceProcAddr;
             }
 
         }
@@ -1311,7 +1310,7 @@
             return VK_ERROR_OUT_OF_HOST_MEMORY;
         while (icd) {
             VkBaseLayerObject * wrapped_gpus;
-            PFN_vkGetProcAddr get_proc_addr = icd->GetProcAddr;
+            PFN_vkGetDeviceProcAddr get_proc_addr = icd->GetDeviceProcAddr;
 
             n = *pPhysicalDeviceCount;
             res = icd->EnumeratePhysicalDevices(
@@ -1406,12 +1405,10 @@
     return NULL;
 }
 
-LOADER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char * pName)
+LOADER_EXPORT void * VKAPI vkGetDeviceProcAddr(VkDevice device, const char * pName)
 {
-    if (gpu == VK_NULL_HANDLE) {
-
-        /* return entrypoint addresses that are global (in the loader)*/
-        return globalGetProcAddr(pName);
+    if (device == VK_NULL_HANDLE) {
+        return NULL;
     }
 
     void *addr;
@@ -1424,7 +1421,7 @@
     }
 
     /* return the dispatch table entrypoint for the fastest case */
-    const VkLayerDispatchTable *disp_table = * (VkLayerDispatchTable **) gpu;
+    const VkLayerDispatchTable *disp_table = * (VkLayerDispatchTable **) device;
     if (disp_table == NULL)
         return NULL;
 
@@ -1432,9 +1429,9 @@
     if (addr)
         return addr;
     else  {
-        if (disp_table->GetProcAddr == NULL)
+        if (disp_table->GetDeviceProcAddr == NULL)
             return NULL;
-        return disp_table->GetProcAddr(gpu, pName);
+        return disp_table->GetDeviceProcAddr(device, pName);
     }
 }
 
diff --git a/loader/loader.h b/loader/loader.h
index e93f258..972b4f1 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -67,7 +67,7 @@
     uint32_t gpu_count;
     VkBaseLayerObject *gpus;
     VkInstance instance;       // instance object from the icd
-    PFN_vkGetProcAddr GetProcAddr;
+    PFN_vkGetDeviceProcAddr GetDeviceProcAddr;
     PFN_vkDestroyInstance DestroyInstance;
     PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
     PFN_vkGetPhysicalDeviceInfo GetPhysicalDeviceInfo;
diff --git a/loader/table_ops.h b/loader/table_ops.h
index 5316720..9a5a0c0 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -29,122 +29,123 @@
 #include "loader_platform.h"
 
 static inline void loader_init_device_dispatch_table(VkLayerDispatchTable *table,
-                                                    PFN_vkGetProcAddr gpa,
-                                                    VkPhysicalDevice gpu)
+                                                    PFN_vkGetDeviceProcAddr gpa,
+                                                    VkDevice dev)
 {
-    table->DestroyDevice = (PFN_vkDestroyDevice) gpa(gpu, "vkDestroyDevice");
-    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->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->BindObjectMemory = (PFN_vkBindObjectMemory) gpa(gpu, "vkBindObjectMemory");
-    table->QueueBindSparseBufferMemory = (PFN_vkQueueBindSparseBufferMemory) gpa(gpu, "vkQueueBindSparseBufferMemory");
-    table->QueueBindSparseImageMemory = (PFN_vkQueueBindSparseImageMemory) gpa(gpu, "vkQueueBindSparseImageMemory");
-    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->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->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(gpu, "vkUpdateDescriptorSets");
-    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->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->DbgSetMessageFilter = (PFN_vkDbgSetMessageFilter) gpa(gpu, "vkDbgSetMessageFilter");
-    table->DbgSetObjectTag = (PFN_vkDbgSetObjectTag) gpa(gpu, "vkDbgSetObjectTag");
-    table->DbgSetDeviceOption = (PFN_vkDbgSetDeviceOption) gpa(gpu, "vkDbgSetDeviceOption");
-    table->CmdDbgMarkerBegin = (PFN_vkCmdDbgMarkerBegin) gpa(gpu, "vkCmdDbgMarkerBegin");
-    table->CmdDbgMarkerEnd = (PFN_vkCmdDbgMarkerEnd) gpa(gpu, "vkCmdDbgMarkerEnd");
-    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");
+    table->GetDeviceProcAddr = gpa;
+    table->DestroyDevice = (PFN_vkDestroyDevice) gpa(dev, "vkDestroyDevice");
+    table->GetDeviceQueue = (PFN_vkGetDeviceQueue) gpa(dev, "vkGetDeviceQueue");
+    table->QueueSubmit = (PFN_vkQueueSubmit) gpa(dev, "vkQueueSubmit");
+    table->QueueWaitIdle = (PFN_vkQueueWaitIdle) gpa(dev, "vkQueueWaitIdle");
+    table->DeviceWaitIdle = (PFN_vkDeviceWaitIdle) gpa(dev, "vkDeviceWaitIdle");
+    table->AllocMemory = (PFN_vkAllocMemory) gpa(dev, "vkAllocMemory");
+    table->FreeMemory = (PFN_vkFreeMemory) gpa(dev, "vkFreeMemory");
+    table->SetMemoryPriority = (PFN_vkSetMemoryPriority) gpa(dev, "vkSetMemoryPriority");
+    table->MapMemory = (PFN_vkMapMemory) gpa(dev, "vkMapMemory");
+    table->UnmapMemory = (PFN_vkUnmapMemory) gpa(dev, "vkUnmapMemory");
+    table->FlushMappedMemoryRanges = (PFN_vkFlushMappedMemoryRanges) gpa(dev, "vkFlushMappedMemoryRanges");
+    table->InvalidateMappedMemoryRanges = (PFN_vkInvalidateMappedMemoryRanges) gpa(dev, "vkInvalidateMappedMemoryRanges");
+    table->PinSystemMemory = (PFN_vkPinSystemMemory) gpa(dev, "vkPinSystemMemory");
+    table->OpenSharedMemory = (PFN_vkOpenSharedMemory) gpa(dev, "vkOpenSharedMemory");
+    table->OpenSharedSemaphore = (PFN_vkOpenSharedSemaphore) gpa(dev, "vkOpenSharedSemaphore");
+    table->OpenPeerMemory = (PFN_vkOpenPeerMemory) gpa(dev, "vkOpenPeerMemory");
+    table->OpenPeerImage = (PFN_vkOpenPeerImage) gpa(dev, "vkOpenPeerImage");
+    table->DestroyObject = (PFN_vkDestroyObject) gpa(dev, "vkDestroyObject");
+    table->GetObjectInfo = (PFN_vkGetObjectInfo) gpa(dev, "vkGetObjectInfo");
+    table->BindObjectMemory = (PFN_vkBindObjectMemory) gpa(dev, "vkBindObjectMemory");
+    table->QueueBindSparseBufferMemory = (PFN_vkQueueBindSparseBufferMemory) gpa(dev, "vkQueueBindSparseBufferMemory");
+    table->QueueBindSparseImageMemory = (PFN_vkQueueBindSparseImageMemory) gpa(dev, "vkQueueBindSparseImageMemory");
+    table->CreateFence = (PFN_vkCreateFence) gpa(dev, "vkCreateFence");
+    table->ResetFences = (PFN_vkResetFences) gpa(dev, "vkResetFences");
+    table->GetFenceStatus = (PFN_vkGetFenceStatus) gpa(dev, "vkGetFenceStatus");
+    table->WaitForFences = (PFN_vkWaitForFences) gpa(dev, "vkWaitForFences");
+    table->CreateSemaphore = (PFN_vkCreateSemaphore) gpa(dev, "vkCreateSemaphore");
+    table->QueueSignalSemaphore = (PFN_vkQueueSignalSemaphore) gpa(dev, "vkQueueSignalSemaphore");
+    table->QueueWaitSemaphore = (PFN_vkQueueWaitSemaphore) gpa(dev, "vkQueueWaitSemaphore");
+    table->CreateEvent = (PFN_vkCreateEvent) gpa(dev, "vkCreateEvent");
+    table->GetEventStatus = (PFN_vkGetEventStatus) gpa(dev, "vkGetEventStatus");
+    table->SetEvent = (PFN_vkSetEvent) gpa(dev, "vkSetEvent");
+    table->ResetEvent = (PFN_vkResetEvent) gpa(dev, "vkResetEvent");
+    table->CreateQueryPool = (PFN_vkCreateQueryPool) gpa(dev, "vkCreateQueryPool");
+    table->GetQueryPoolResults = (PFN_vkGetQueryPoolResults) gpa(dev, "vkGetQueryPoolResults");
+    table->GetFormatInfo = (PFN_vkGetFormatInfo) gpa(dev, "vkGetFormatInfo");
+    table->CreateBuffer = (PFN_vkCreateBuffer) gpa(dev, "vkCreateBuffer");
+    table->CreateBufferView = (PFN_vkCreateBufferView) gpa(dev, "vkCreateBufferView");
+    table->CreateImage = (PFN_vkCreateImage) gpa(dev, "vkCreateImage");
+    table->GetImageSubresourceInfo = (PFN_vkGetImageSubresourceInfo) gpa(dev, "vkGetImageSubresourceInfo");
+    table->CreateImageView = (PFN_vkCreateImageView) gpa(dev, "vkCreateImageView");
+    table->CreateColorAttachmentView = (PFN_vkCreateColorAttachmentView) gpa(dev, "vkCreateColorAttachmentView");
+    table->CreateDepthStencilView = (PFN_vkCreateDepthStencilView) gpa(dev, "vkCreateDepthStencilView");
+    table->CreateShader = (PFN_vkCreateShader) gpa(dev, "vkCreateShader");
+    table->CreateGraphicsPipeline = (PFN_vkCreateGraphicsPipeline) gpa(dev, "vkCreateGraphicsPipeline");
+    table->CreateGraphicsPipelineDerivative = (PFN_vkCreateGraphicsPipelineDerivative) gpa(dev, "vkCreateGraphicsPipelineDerivative");
+    table->CreateComputePipeline = (PFN_vkCreateComputePipeline) gpa(dev, "vkCreateComputePipeline");
+    table->StorePipeline = (PFN_vkStorePipeline) gpa(dev, "vkStorePipeline");
+    table->LoadPipeline = (PFN_vkLoadPipeline) gpa(dev, "vkLoadPipeline");
+    table->LoadPipelineDerivative = (PFN_vkLoadPipelineDerivative) gpa(dev, "vkLoadPipelineDerivative");
+    table->CreatePipelineLayout = (PFN_vkCreatePipelineLayout) gpa(dev, "vkCreatePipelineLayout");
+    table->CreateSampler = (PFN_vkCreateSampler) gpa(dev, "vkCreateSampler");
+    table->CreateDescriptorSetLayout = (PFN_vkCreateDescriptorSetLayout) gpa(dev, "vkCreateDescriptorSetLayout");
+    table->CreateDescriptorPool = (PFN_vkCreateDescriptorPool) gpa(dev, "vkCreateDescriptorPool");
+    table->ResetDescriptorPool = (PFN_vkResetDescriptorPool) gpa(dev, "vkResetDescriptorPool");
+    table->AllocDescriptorSets = (PFN_vkAllocDescriptorSets) gpa(dev, "vkAllocDescriptorSets");
+    table->ClearDescriptorSets = (PFN_vkClearDescriptorSets) gpa(dev, "vkClearDescriptorSets");
+    table->UpdateDescriptorSets = (PFN_vkUpdateDescriptorSets) gpa(dev, "vkUpdateDescriptorSets");
+    table->CreateDynamicViewportState = (PFN_vkCreateDynamicViewportState) gpa(dev, "vkCreateDynamicViewportState");
+    table->CreateDynamicRasterState = (PFN_vkCreateDynamicRasterState) gpa(dev, "vkCreateDynamicRasterState");
+    table->CreateDynamicColorBlendState = (PFN_vkCreateDynamicColorBlendState) gpa(dev, "vkCreateDynamicColorBlendState");
+    table->CreateDynamicDepthStencilState = (PFN_vkCreateDynamicDepthStencilState) gpa(dev, "vkCreateDynamicDepthStencilState");
+    table->CreateCommandBuffer = (PFN_vkCreateCommandBuffer) gpa(dev, "vkCreateCommandBuffer");
+    table->BeginCommandBuffer = (PFN_vkBeginCommandBuffer) gpa(dev, "vkBeginCommandBuffer");
+    table->EndCommandBuffer = (PFN_vkEndCommandBuffer) gpa(dev, "vkEndCommandBuffer");
+    table->ResetCommandBuffer = (PFN_vkResetCommandBuffer) gpa(dev, "vkResetCommandBuffer");
+    table->CmdBindPipeline = (PFN_vkCmdBindPipeline) gpa(dev, "vkCmdBindPipeline");
+    table->CmdBindDynamicStateObject = (PFN_vkCmdBindDynamicStateObject) gpa(dev, "vkCmdBindDynamicStateObject");
+    table->CmdBindDescriptorSets = (PFN_vkCmdBindDescriptorSets) gpa(dev, "vkCmdBindDescriptorSets");
+    table->CmdBindVertexBuffers = (PFN_vkCmdBindVertexBuffers) gpa(dev, "vkCmdBindVertexBuffers");
+    table->CmdBindIndexBuffer = (PFN_vkCmdBindIndexBuffer) gpa(dev, "vkCmdBindIndexBuffer");
+    table->CmdDraw = (PFN_vkCmdDraw) gpa(dev, "vkCmdDraw");
+    table->CmdDrawIndexed = (PFN_vkCmdDrawIndexed) gpa(dev, "vkCmdDrawIndexed");
+    table->CmdDrawIndirect = (PFN_vkCmdDrawIndirect) gpa(dev, "vkCmdDrawIndirect");
+    table->CmdDrawIndexedIndirect = (PFN_vkCmdDrawIndexedIndirect) gpa(dev, "vkCmdDrawIndexedIndirect");
+    table->CmdDispatch = (PFN_vkCmdDispatch) gpa(dev, "vkCmdDispatch");
+    table->CmdDispatchIndirect = (PFN_vkCmdDispatchIndirect) gpa(dev, "vkCmdDispatchIndirect");
+    table->CmdCopyBuffer = (PFN_vkCmdCopyBuffer) gpa(dev, "vkCmdCopyBuffer");
+    table->CmdCopyImage = (PFN_vkCmdCopyImage) gpa(dev, "vkCmdCopyImage");
+    table->CmdBlitImage = (PFN_vkCmdBlitImage) gpa(dev, "vkCmdBlitImage");
+    table->CmdCopyBufferToImage = (PFN_vkCmdCopyBufferToImage) gpa(dev, "vkCmdCopyBufferToImage");
+    table->CmdCopyImageToBuffer = (PFN_vkCmdCopyImageToBuffer) gpa(dev, "vkCmdCopyImageToBuffer");
+    table->CmdUpdateBuffer = (PFN_vkCmdUpdateBuffer) gpa(dev, "vkCmdUpdateBuffer");
+    table->CmdFillBuffer = (PFN_vkCmdFillBuffer) gpa(dev, "vkCmdFillBuffer");
+    table->CmdClearColorImage = (PFN_vkCmdClearColorImage) gpa(dev, "vkCmdClearColorImage");
+    table->CmdClearDepthStencil = (PFN_vkCmdClearDepthStencil) gpa(dev, "vkCmdClearDepthStencil");
+    table->CmdResolveImage = (PFN_vkCmdResolveImage) gpa(dev, "vkCmdResolveImage");
+    table->CmdSetEvent = (PFN_vkCmdSetEvent) gpa(dev, "vkCmdSetEvent");
+    table->CmdResetEvent = (PFN_vkCmdResetEvent) gpa(dev, "vkCmdResetEvent");
+    table->CmdWaitEvents = (PFN_vkCmdWaitEvents) gpa(dev, "vkCmdWaitEvents");
+    table->CmdPipelineBarrier = (PFN_vkCmdPipelineBarrier) gpa(dev, "vkCmdPipelineBarrier");
+    table->CmdBeginQuery = (PFN_vkCmdBeginQuery) gpa(dev, "vkCmdBeginQuery");
+    table->CmdEndQuery = (PFN_vkCmdEndQuery) gpa(dev, "vkCmdEndQuery");
+    table->CmdResetQueryPool = (PFN_vkCmdResetQueryPool) gpa(dev, "vkCmdResetQueryPool");
+    table->CmdWriteTimestamp = (PFN_vkCmdWriteTimestamp) gpa(dev, "vkCmdWriteTimestamp");
+    table->CmdCopyQueryPoolResults = (PFN_vkCmdCopyQueryPoolResults) gpa(dev, "vkCmdCopyQueryPoolResults");
+    table->CmdInitAtomicCounters = (PFN_vkCmdInitAtomicCounters) gpa(dev, "vkCmdInitAtomicCounters");
+    table->CmdLoadAtomicCounters = (PFN_vkCmdLoadAtomicCounters) gpa(dev, "vkCmdLoadAtomicCounters");
+    table->CmdSaveAtomicCounters = (PFN_vkCmdSaveAtomicCounters) gpa(dev, "vkCmdSaveAtomicCounters");
+    table->CreateFramebuffer = (PFN_vkCreateFramebuffer) gpa(dev, "vkCreateFramebuffer");
+    table->CreateRenderPass = (PFN_vkCreateRenderPass) gpa(dev, "vkCreateRenderPass");
+    table->CmdBeginRenderPass = (PFN_vkCmdBeginRenderPass) gpa(dev, "vkCmdBeginRenderPass");
+    table->CmdEndRenderPass = (PFN_vkCmdEndRenderPass) gpa(dev, "vkCmdEndRenderPass");
+    table->DbgSetValidationLevel = (PFN_vkDbgSetValidationLevel) gpa(dev, "vkDbgSetValidationLevel");
+    table->DbgSetMessageFilter = (PFN_vkDbgSetMessageFilter) gpa(dev, "vkDbgSetMessageFilter");
+    table->DbgSetObjectTag = (PFN_vkDbgSetObjectTag) gpa(dev, "vkDbgSetObjectTag");
+    table->DbgSetDeviceOption = (PFN_vkDbgSetDeviceOption) gpa(dev, "vkDbgSetDeviceOption");
+    table->CmdDbgMarkerBegin = (PFN_vkCmdDbgMarkerBegin) gpa(dev, "vkCmdDbgMarkerBegin");
+    table->CmdDbgMarkerEnd = (PFN_vkCmdDbgMarkerEnd) gpa(dev, "vkCmdDbgMarkerEnd");
+    table->CreateSwapChainWSI = (PFN_vkCreateSwapChainWSI) gpa(dev, "vkCreateSwapChainWSI");
+    table->DestroySwapChainWSI = (PFN_vkDestroySwapChainWSI) gpa(dev, "vkDestroySwapChainWSI");
+    table->GetSwapChainInfoWSI = (PFN_vkGetSwapChainInfoWSI) gpa(dev, "vkGetSwapChainInfoWSI");
+    table->QueuePresentWSI = (PFN_vkQueuePresentWSI) gpa(dev, "vkQueuePresentWSI");
 }
 
 static inline void *loader_lookup_device_dispatch_table(
@@ -155,6 +156,8 @@
         return NULL;
 
     name += 2;
+    if (!strcmp(name, "GetDeviceProcAddr"))
+        return (void *) table->GetDeviceProcAddr;
     if (!strcmp(name, "DestroyDevice"))
         return (void *) table->DestroyDevice;
     if (!strcmp(name, "GetDeviceQueue"))
@@ -394,7 +397,6 @@
     table->EnumeratePhysicalDevices = (PFN_vkEnumeratePhysicalDevices) gpa(inst, "vkEnumeratePhysicalDevices");
     table->GetPhysicalDeviceInfo = (PFN_vkGetPhysicalDeviceInfo) gpa(inst, "vkGetPhysicalDeviceInfo");
     table->GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr) gpa(inst, "vkGetInstanceProcAddr");
-    table->GetProcAddr = (PFN_vkGetProcAddr) gpa(inst, "vkGetProcAddr");
     table->CreateDevice = (PFN_vkCreateDevice) gpa(inst, "vkCreateDevice");
     table->GetGlobalExtensionInfo = (PFN_vkGetGlobalExtensionInfo) gpa(inst,"vkGetGlobalExtensionInfo");
     table->GetPhysicalDeviceExtensionInfo = (PFN_vkGetPhysicalDeviceExtensionInfo) gpa(inst, "vkGetPhysicalDeviceExtensionInfo");
@@ -424,8 +426,6 @@
         return (void *) table->GetPhysicalDeviceInfo;
     if (!strcmp(name, "GetInstanceProcAddr"))
         return (void *) table->GetInstanceProcAddr;
-    if (!strcmp(name, "GetProcAddr"))
-        return (void *) table->GetProcAddr;
     if (!strcmp(name, "CreateDevice"))
         return (void *) table->CreateDevice;
     if (!strcmp(name, "GetGlobalExtensionInfo"))
@@ -446,4 +446,4 @@
         return (void *) table->GetDisplayInfoWSI;
 
     return NULL;
-}
\ No newline at end of file
+}
diff --git a/loader/vk-loader-generate.py b/loader/vk-loader-generate.py
index 1d55d56..f0fcbdb 100755
--- a/loader/vk-loader-generate.py
+++ b/loader/vk-loader-generate.py
@@ -56,7 +56,7 @@
            return False
 
     def _is_loader_non_trampoline_entrypoint(self, proto):
-        if proto.name in ["GetProcAddr", "EnumeratePhysicalDevices", "EnumerateLayers", "DbgRegisterMsgCallback", "DbgUnregisterMsgCallback", "DbgSetGlobalOption", "DestroyInstance"]:
+        if proto.name in ["GetDeviceProcAddr", "EnumeratePhysicalDevices", "EnumerateLayers", "DbgRegisterMsgCallback", "DbgUnregisterMsgCallback", "DbgSetGlobalOption", "DestroyInstance"]:
             return True
         return not self.is_dispatchable_object_first_param(proto)
 
@@ -250,7 +250,7 @@
                              (proto.name, proto.name))
             func.append("static inline void %s_init_device_dispatch_table(VkLayerDispatchTable *table,"
                 % self.prefix)
-            func.append("%s                                              PFN_vkGetProcAddr gpa,"
+            func.append("%s                                              PFN_vkGetDeviceProcAddr gpa,"
                 % (" " * len(self.prefix)))
             func.append("%s                                              VkPhysicalDevice gpu)"
                 % (" " * len(self.prefix)))
@@ -365,7 +365,7 @@
         self.intercepted = [proto.name for proto in self.protos]
 
         for proto in self.protos:
-            if proto.name == "GetProcAddr":
+            if proto.name == "GetDeviceProcAddr":
                 self.gpa = proto
 
         super().run()
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 2faea49..809472f 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -76,8 +76,6 @@
     VkPhysicalDeviceMemoryProperties memory_properties() const;
     std::vector<VkPhysicalDeviceQueueProperties> queue_properties() const;
 
-    // vkGetProcAddr()
-    void *get_proc(const char *name) const { return vkGetProcAddr(gpu_, name); }
 
     // vkGetGlobalExtensionInfo()
     std::vector<const char *> extensions() const;
@@ -212,6 +210,9 @@
 
     const PhysicalGpu &gpu() const { return gpu_; }
 
+    // vkGetDeviceProcAddr()
+    void *get_proc(const char *name) const { return vkGetDeviceProcAddr(obj(), name); }
+
     // vkGetDeviceQueue()
     const std::vector<Queue *> &graphics_queues() const { return queues_[GRAPHICS]; }
     const std::vector<Queue *> &compute_queues() { return queues_[COMPUTE]; }
diff --git a/vk-generate.py b/vk-generate.py
index ca3a6d3..3375b1b 100755
--- a/vk-generate.py
+++ b/vk-generate.py
@@ -117,13 +117,13 @@
             for proto in self.protos:
                 if proto.name == "CreateInstance" or proto.name == "GetGlobalExtensionInfo" or proto.name == "GetDisplayInfoWSI" or proto.params[0].ty == "VkInstance" or proto.params[0].ty == "VkPhysicalDevice":
                     continue
-                stmts.append("table->%s = (PFN_vk%s) gpa(gpu, \"vk%s\");" %
+                stmts.append("table->%s = (PFN_vk%s) gpa(device, \"vk%s\");" %
                         (proto.name, proto.name, proto.name))
             func.append("static inline void %s_initialize_dispatch_table(VkLayerDispatchTable *table,"
                 % self.prefix)
-            func.append("%s                                              PFN_vkGetProcAddr gpa,"
+            func.append("%s                                              PFN_vkGetDeviceProcAddr gpa,"
                 % (" " * len(self.prefix)))
-            func.append("%s                                              VkPhysicalDevice gpu)"
+            func.append("%s                                              VkDevice device)"
                 % (" " * len(self.prefix)))
         else:
             for proto in self.protos:
@@ -188,7 +188,7 @@
 
     def generate_body(self):
         for proto in self.protos:
-            if proto.name == "GetProcAddr":
+            if proto.name == "GetDeviceProcAddr":
                 gpa_proto = proto
             if proto.name == "GetInstanceProcAddr":
                 gpa_instance_proto = proto
@@ -231,11 +231,12 @@
                     "EnumeratePhysicalDevices",
                     "CreateInstance",
                     "DestroyInstance",
-                    "GetProcAddr",
+                    "GetDeviceProcAddr",
+                    "GetInstanceProcAddr",
                 ],
                 "layer": [
                     "GetInstanceProcAddr",
-                    "GetProcAddr",
+                    "GetDeviceProcAddr",
                     "EnumerateLayers",
                     "GetGlobalExtensionInfo",
                 ],
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 617406b..43c1fc2 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -286,7 +286,7 @@
         funcs = []
         intercepted = []
         for proto in self.protos:
-            if proto.name == "GetProcAddr" or proto.name == "GetInstanceProcAddr":
+            if proto.name == "GetDeviceProcAddr" or proto.name == "GetInstanceProcAddr":
                 intercepted.append(proto)
             else:
                 intercept = self.generate_intercept(proto, qual)
@@ -410,13 +410,13 @@
 
     def _generate_layer_gpa_function(self, extensions=[], instance_extensions=[]):
         func_body = []
-        func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalDevice gpu, const char* funcName)\n"
+        func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)\n"
                          "{\n"
-                         "    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;\n"
+                         "    VkBaseLayerObject* devw = (VkBaseLayerObject *) device;\n"
                          "    void* addr;\n"
-                         "    if (gpu == VK_NULL_HANDLE)\n"
+                         "    if (device == VK_NULL_HANDLE)\n"
                          "        return NULL;\n"
-                         "    pCurObj = gpuw;\n"
+                         "    pCurObj = devw;\n"
                          "    loader_platform_thread_once(&initOnce, init%s);\n\n"
                          "    loader_platform_thread_once(&tabDeviceOnce, initDeviceTable);\n\n"
                          "    addr = layer_intercept_proc(funcName);\n"
@@ -433,9 +433,9 @@
                 func_body.append('    else if (!strncmp("%s", funcName, sizeof("%s")))\n'
                                  '        return %s%s%s;' % (ext_name, ext_name, cpp_prefix, ext_name, cpp_postfix))
         func_body.append("    else {\n"
-                         "        if (gpuw->pGPA == NULL)\n"
+                         "        if (devw->pGPA == NULL)\n"
                          "            return NULL;\n"
-                         "        return gpuw->pGPA((VkObject)gpuw->nextObject, funcName);\n"
+                         "        return devw->pGPA((VkObject)devw->nextObject, funcName);\n"
                          "    }\n"
                          "}\n")
         func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(VkInstance inst, const char* funcName)\n"
@@ -498,10 +498,10 @@
         func_body.append('')
         func_body.append('static void initDeviceTable(void)')
         func_body.append('{')
-        func_body.append('    PFN_vkGetProcAddr fpNextGPA;')
-        func_body.append('    fpNextGPA = (PFN_vkGetProcAddr) pCurObj->pGPA;')
+        func_body.append('    PFN_vkGetDeviceProcAddr fpNextGPA;')
+        func_body.append('    fpNextGPA = (PFN_vkGetDeviceProcAddr) pCurObj->pGPA;')
         func_body.append('    assert(fpNextGPA);')
-        func_body.append('    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalDevice) pCurObj->nextObject);')
+        func_body.append('    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkDevice) pCurObj->nextObject);')
         func_body.append('}')
         func_body.append('')
         func_body.append('static void initInstanceTable(void)')
@@ -730,10 +730,10 @@
         func_body.append('')
         func_body.append('static void initDeviceTable(void)')
         func_body.append('{')
-        func_body.append('    PFN_vkGetProcAddr fpNextGPA;')
-        func_body.append('    fpNextGPA = (PFN_vkGetProcAddr) pCurObj->pGPA;')
+        func_body.append('    PFN_vkGetDeviceProcAddr fpNextGPA;')
+        func_body.append('    fpNextGPA = (PFN_vkGetDeviceProcAddr) pCurObj->pGPA;')
         func_body.append('    assert(fpNextGPA);')
-        func_body.append('    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkPhysicalDevice) pCurObj->nextObject);')
+        func_body.append('    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkDevice) pCurObj->nextObject);')
         func_body.append('}')
         func_body.append('')
         func_body.append('static void initInstanceTable(void)')
diff --git a/vulkan.py b/vulkan.py
index f18ab68..796a280 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -239,8 +239,8 @@
             [Param("VkInstance", "instance"),
              Param("const char*", "pName")]),
 
-        Proto("void*", "GetProcAddr",
-            [Param("VkPhysicalDevice", "gpu"),
+        Proto("void*", "GetDeviceProcAddr",
+            [Param("VkDevice", "device"),
              Param("const char*", "pName")]),
 
         Proto("VkResult", "CreateDevice",