loader: refactor layer activation function to handle more general inputs

Renamed structure types as well.

TODO: verify vk-layer-generate.py

v2: fix LoaderEntrypointsSubcommand (olv)

13 files changed, 181 insertions, 129 deletions

diff --git a/icd/README.md b/icd/README.md
index 871d1c68..4077046a 100644
--- a/icd/README.md
+++ b/icd/README.md
@@ -7,7 +7,7 @@ This sample driver implementation provide multiple subcomponents required to bui
 
 common/ provides helper and utility functions, as well as all VK entry points
 except vkInitAndEnumerateGpus.  Hardware drivers are required to provide that
-function, and to embed a "VK_LAYER_DISPATCH_TABLE *" as the first member of
+function, and to embed a "VkLayerDispatchTable *" as the first member of
 VkPhysicalGpu and all VkBaseObject.
 
 Thread safety
diff --git a/include/vkLayer.h b/include/vkLayer.h
index f5b6fac3..97c9b375 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -18,14 +18,14 @@
 #endif
 
 
-typedef struct _VK_BASE_LAYER_OBJECT
+typedef struct VkBaseLayerObject_
 {
     PFN_vkGetProcAddr pGPA;
     VkBaseObject nextObject;
     VkBaseObject baseObject;
-} VK_BASE_LAYER_OBJECT;
+} VkBaseLayerObject;
 
-typedef struct _VK_LAYER_DISPATCH_TABLE
+typedef struct VkLayerDispatchTable_
 {
     PFN_vkGetProcAddr GetProcAddr;
     PFN_vkCreateInstance CreateInstance;
@@ -156,7 +156,7 @@ typedef struct _VK_LAYER_DISPATCH_TABLE
     PFN_vkWsiX11CreatePresentableImage WsiX11CreatePresentableImage;
     PFN_vkWsiX11QueuePresent WsiX11QueuePresent;
 #endif // WIN32
-} VK_LAYER_DISPATCH_TABLE;
+} VkLayerDispatchTable;
 
 // LL node for tree of dbg callback functions
 typedef struct _VK_LAYER_DBG_FUNCTION_NODE
diff --git a/layers/basic.cpp b/layers/basic.cpp
index 9501c13e..3854577c 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -32,17 +32,17 @@
 // being used:
 #include "loader_platform.h"
 
-static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap;
+static std::unordered_map<void *, VkLayerDispatchTable *> tableMap;
 
-static VK_LAYER_DISPATCH_TABLE * initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw)
+static VkLayerDispatchTable * initLayerTable(const VkBaseLayerObject *gpuw)
 {
-    VK_LAYER_DISPATCH_TABLE *pTable;
+    VkLayerDispatchTable *pTable;
 
     assert(gpuw);
-    std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap.find((void *) gpuw);
+    std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap.find((void *) gpuw);
     if (it == tableMap.end())
     {
-        pTable =  new VK_LAYER_DISPATCH_TABLE;
+        pTable =  new VkLayerDispatchTable;
         tableMap[(void *) gpuw] = pTable;
     } else
     {
@@ -64,7 +64,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkLayerExtension1(VkDevice device)
 VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)
 {
     VkResult result;
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
 
     /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
     if (!strncmp(pExtName, "vkLayerExtension1", strlen("vkLayerExtension1")))
@@ -76,7 +76,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const ch
     } else if (!tableMap.empty() && (tableMap.find(gpuw) != tableMap.end()))
     {
         printf("At start of wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
-        VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
+        VkLayerDispatchTable* pTable = tableMap[gpuw];
         result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName);
         printf("Completed wrapped vkGetExtensionSupport() call w/ gpu: %p\n", (void*)gpu);
     } else
@@ -88,8 +88,8 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const ch
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
-    VK_LAYER_DISPATCH_TABLE* pTable = tableMap[gpuw];
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkLayerDispatchTable* pTable = tableMap[gpuw];
 
     printf("At start of wrapped vkCreateDevice() call w/ gpu: %p\n", (void*)gpu);
     VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice);
@@ -100,7 +100,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceC
 }
 VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData)
 {
-    VK_LAYER_DISPATCH_TABLE* pTable = tableMap[device];
+    VkLayerDispatchTable* pTable = tableMap[device];
 
     printf("At start of wrapped vkGetFormatInfo() call w/ device: %p\n", (void*)device);
     VkResult result = pTable->GetFormatInfo(device, format, infoType, pDataSize, pData);
@@ -112,8 +112,8 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLa
 {
     if (gpu != NULL)
     {
-        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
-        VK_LAYER_DISPATCH_TABLE* pTable = initLayerTable(gpuw);
+        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+        VkLayerDispatchTable* pTable = initLayerTable(gpuw);
 
         printf("At start of wrapped vkEnumerateLayers() call w/ gpu: %p\n", gpu);
         VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
@@ -124,7 +124,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLa
             return VK_ERROR_INVALID_POINTER;
 
         // Example of a layer that is only compatible with Intel's GPUs
-        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT*) pReserved;
+        VkBaseLayerObject* gpuw = (VkBaseLayerObject*) pReserved;
         PFN_vkGetGpuInfo fpGetGpuInfo;
         VkPhysicalGpuProperties gpuProps;
         size_t dataSize = sizeof(VkPhysicalGpuProperties);
@@ -147,7 +147,7 @@ VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* pName)
     if (gpu == NULL)
         return NULL;
 
-    initLayerTable((const VK_BASE_LAYER_OBJECT *) gpu);
+    initLayerTable((const VkBaseLayerObject *) gpu);
 
     if (!strncmp("vkGetProcAddr", pName, sizeof("vkGetProcAddr")))
         return (void *) vkGetProcAddr;
@@ -162,7 +162,7 @@ VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* pName)
     else if (!strncmp("vkLayerExtension1", pName, sizeof("vkLayerExtension1")))
         return (void *) vkLayerExtension1;
     else {
-        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
         if (gpuw->pGPA == NULL)
             return NULL;
         return gpuw->pGPA((VkPhysicalGpu) gpuw->nextObject, pName);
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 6ff0fcee..cb3e6833 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -54,8 +54,8 @@ unordered_map<VkCmdBuffer, GLOBAL_CB_NODE*> cmdBufferMap;
 unordered_map<VkRenderPass, VkRenderPassCreateInfo*> renderPassMap;
 unordered_map<VkFramebuffer, VkFramebufferCreateInfo*> frameBufferMap;
 
-static VK_LAYER_DISPATCH_TABLE nextTable;
-static VK_BASE_LAYER_OBJECT *pCurObj;
+static VkLayerDispatchTable nextTable;
+static VkBaseLayerObject *pCurObj;
 static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
 // TODO : This can be much smarter, using separate locks for separate global data
 static int globalLockInitialized = 0;
@@ -1443,7 +1443,7 @@ static void initDrawState(void)
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&g_initOnce, initDrawState);
     VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice);
@@ -1469,7 +1469,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     VkResult result;
     /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */
     if (!strcmp(pExtName, "DrawState") || !strcmp(pExtName, "drawStateDumpDotFile") ||
@@ -1490,7 +1490,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLa
 {
     if (gpu != NULL)
     {
-        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
         pCurObj = gpuw;
         loader_platform_thread_once(&g_initOnce, initDrawState);
         VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
@@ -2690,7 +2690,7 @@ void drawStateDumpPngFile(char* outFileName)
 
 VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
 
     if (gpu == NULL)
         return NULL;
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 5180ed70..2c351573 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -32,7 +32,7 @@
 #define LAYER_NAME_STR "GlaveSnapshot"
 #define LAYER_ABBREV_STR "GLVSnap"
 
-static VK_LAYER_DISPATCH_TABLE nextTable;
+static VkLayerDispatchTable nextTable;
 static VK_BASE_LAYER_OBJECT *pCurObj;
 
 // The following is #included again to catch certain OS-specific functions being used:
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index bde5950a..1a00669c 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -41,8 +41,8 @@ using namespace std;
 #include "loader_platform.h"
 #include "layers_msg.h"
 
-static VK_LAYER_DISPATCH_TABLE nextTable;
-static VK_BASE_LAYER_OBJECT *pCurObj;
+static VkLayerDispatchTable nextTable;
+static VkBaseLayerObject *pCurObj;
 static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
 // TODO : This can be much smarter, using separate locks for separate global data
 static int globalLockInitialized = 0;
@@ -823,7 +823,7 @@ static void initMemTracker(void)
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&g_initOnce, initMemTracker);
     VkResult result = nextTable.CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice);
@@ -867,7 +867,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     VkResult result;
     /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */
     if (!strcmp(pExtName, "MemTracker"))
@@ -888,7 +888,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLa
 {
         if (gpu != NULL)
     {
-        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
         pCurObj = gpuw;
         loader_platform_thread_once(&g_initOnce, initMemTracker);
         VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount,
@@ -1905,7 +1905,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_
 
 VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
 
     if (gpu == NULL)
         return NULL;
diff --git a/layers/multi.cpp b/layers/multi.cpp
index 1c9dc178..53286c57 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -34,21 +34,21 @@
 // being used:
 #include "loader_platform.h"
 
-static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum);
+static void initLayerTable(const VkBaseLayerObject *gpuw, VkLayerDispatchTable *pTable, const unsigned int layerNum);
 
 /******************************** Layer multi1 functions **************************/
-static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap1;
+static std::unordered_map<void *, VkLayerDispatchTable *> tableMap1;
 static bool layer1_first_activated = false;
 
-static VK_LAYER_DISPATCH_TABLE * getLayer1Table(const VK_BASE_LAYER_OBJECT *gpuw)
+static VkLayerDispatchTable * getLayer1Table(const VkBaseLayerObject *gpuw)
 {
-    VK_LAYER_DISPATCH_TABLE *pTable;
+    VkLayerDispatchTable *pTable;
 
     assert(gpuw);
-    std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap1.find((void *) gpuw);
+    std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap1.find((void *) gpuw);
     if (it == tableMap1.end())
     {
-        pTable =  new VK_LAYER_DISPATCH_TABLE;
+        pTable =  new VkLayerDispatchTable;
         tableMap1[(void *) gpuw] = pTable;
         initLayerTable(gpuw, pTable, 1);
         return pTable;
@@ -65,8 +65,8 @@ extern "C" {
 VK_LAYER_EXPORT VkResult VKAPI multi1CreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo,
                                                       VkDevice* pDevice)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
-    VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkLayerDispatchTable* pTable = getLayer1Table(gpuw);
 
     printf("At start of multi1 layer vkCreateDevice()\n");
     VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice);
@@ -79,7 +79,7 @@ VK_LAYER_EXPORT VkResult VKAPI multi1CreateDevice(VkPhysicalGpu gpu, const VkDev
 VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo,
                                                                 VkPipeline* pPipeline)
 {
-    VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[device];
+    VkLayerDispatchTable* pTable = tableMap1[device];
 
     printf("At start of multi1 layer vkCreateGraphicsPipeline()\n");
     VkResult result = pTable->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
@@ -91,7 +91,7 @@ VK_LAYER_EXPORT VkResult VKAPI multi1CreateGraphicsPipeline(VkDevice device, con
 
 VK_LAYER_EXPORT VkResult VKAPI multi1StorePipeline(VkPipeline pipeline, size_t* pDataSize, void* pData)
 {
-    VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[pipeline];
+    VkLayerDispatchTable* pTable = tableMap1[pipeline];
 
     printf("At start of multi1 layer vkStorePipeline()\n");
     VkResult result = pTable->StorePipeline(pipeline, pDataSize, pData);
@@ -106,8 +106,8 @@ VK_LAYER_EXPORT VkResult VKAPI multi1EnumerateLayers(VkPhysicalGpu gpu, size_t m
     if (gpu == NULL)
         return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
 
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
-    VK_LAYER_DISPATCH_TABLE* pTable = getLayer1Table(gpuw);
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkLayerDispatchTable* pTable = getLayer1Table(gpuw);
 
     printf("At start of multi1 layer vkEnumerateLayers()\n");
     VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
@@ -117,7 +117,7 @@ VK_LAYER_EXPORT VkResult VKAPI multi1EnumerateLayers(VkPhysicalGpu gpu, size_t m
 
 VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VkPhysicalGpu gpu, const char* pName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
 
     if (gpu == NULL)
         return NULL;
@@ -142,18 +142,18 @@ VK_LAYER_EXPORT void * VKAPI multi1GetProcAddr(VkPhysicalGpu gpu, const char* pN
 }
 
 /******************************** Layer multi2 functions **************************/
-static std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *> tableMap2;
+static std::unordered_map<void *, VkLayerDispatchTable *> tableMap2;
 static bool layer2_first_activated = false;
 
-static VK_LAYER_DISPATCH_TABLE * getLayer2Table(const VK_BASE_LAYER_OBJECT *gpuw)
+static VkLayerDispatchTable * getLayer2Table(const VkBaseLayerObject *gpuw)
 {
-    VK_LAYER_DISPATCH_TABLE *pTable;
+    VkLayerDispatchTable *pTable;
 
     assert(gpuw);
-    std::unordered_map<void *, VK_LAYER_DISPATCH_TABLE *>::const_iterator it = tableMap2.find((void *) gpuw);
+    std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap2.find((void *) gpuw);
     if (it == tableMap2.end())
     {
-        pTable =  new VK_LAYER_DISPATCH_TABLE;
+        pTable =  new VkLayerDispatchTable;
         tableMap2[(void *) gpuw] = pTable;
         initLayerTable(gpuw, pTable, 2);
         return pTable;
@@ -166,8 +166,8 @@ static VK_LAYER_DISPATCH_TABLE * getLayer2Table(const VK_BASE_LAYER_OBJECT *gpuw
 VK_LAYER_EXPORT VkResult VKAPI multi2CreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo,
                                                       VkDevice* pDevice)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
-    VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkLayerDispatchTable* pTable = getLayer2Table(gpuw);
 
     printf("At start of multi2 vkCreateDevice()\n");
     VkResult result = pTable->CreateDevice((VkPhysicalGpu)gpuw->nextObject, pCreateInfo, pDevice);
@@ -180,7 +180,7 @@ VK_LAYER_EXPORT VkResult VKAPI multi2CreateDevice(VkPhysicalGpu gpu, const VkDev
 VK_LAYER_EXPORT VkResult VKAPI multi2CreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo,
                                                              VkCmdBuffer* pCmdBuffer)
 {
-    VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[device];
+    VkLayerDispatchTable* pTable = tableMap2[device];
 
     printf("At start of multi2 layer vkCreateCommandBuffer()\n");
     VkResult result = pTable->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
@@ -192,7 +192,7 @@ VK_LAYER_EXPORT VkResult VKAPI multi2CreateCommandBuffer(VkDevice device, const
 
 VK_LAYER_EXPORT VkResult VKAPI multi2BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
 {
-    VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[cmdBuffer];
+    VkLayerDispatchTable* pTable = tableMap2[cmdBuffer];
 
     printf("At start of multi2 layer vkBeginCommandBuffer()\n");
     VkResult result = pTable->BeginCommandBuffer(cmdBuffer, pBeginInfo);
@@ -208,8 +208,8 @@ VK_LAYER_EXPORT VkResult VKAPI multi2EnumerateLayers(VkPhysicalGpu gpu, size_t m
     if (gpu == NULL)
         return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
 
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
-    VK_LAYER_DISPATCH_TABLE* pTable = getLayer2Table(gpuw);
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkLayerDispatchTable* pTable = getLayer2Table(gpuw);
 
     printf("At start of multi2 layer vkEnumerateLayers()\n");
     VkResult result = pTable->EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
@@ -219,7 +219,7 @@ VK_LAYER_EXPORT VkResult VKAPI multi2EnumerateLayers(VkPhysicalGpu gpu, size_t m
 
 VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VkPhysicalGpu gpu, const char* pName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
 
     if (gpu == NULL)
         return NULL;
@@ -262,7 +262,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLa
 VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)
 {
     VkResult result;
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
 
     /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
     if (!strncmp(pExtName, "multi1", strlen("multi1")))
@@ -273,11 +273,11 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const ch
         result = VK_SUCCESS;
     } else if (!tableMap1.empty() && (tableMap1.find(gpuw) != tableMap1.end()))
     {
-        VK_LAYER_DISPATCH_TABLE* pTable = tableMap1[gpuw];
+        VkLayerDispatchTable* pTable = tableMap1[gpuw];
         result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName);
     } else if (!tableMap2.empty() && (tableMap2.find(gpuw) != tableMap2.end()))
     {
-        VK_LAYER_DISPATCH_TABLE* pTable = tableMap2[gpuw];
+        VkLayerDispatchTable* pTable = tableMap2[gpuw];
         result = pTable->GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName);
     } else
     {
@@ -310,7 +310,7 @@ VK_LAYER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* pName)
 }    //extern "C"
 #endif
 
-static void initLayerTable(const VK_BASE_LAYER_OBJECT *gpuw, VK_LAYER_DISPATCH_TABLE *pTable, const unsigned int layerNum)
+static void initLayerTable(const VkBaseLayerObject *gpuw, VkLayerDispatchTable *pTable, const unsigned int layerNum)
 {
     if (layerNum == 2 && layer1_first_activated == false)
         layer2_first_activated = true;
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index e11998f8..1ce946ae 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -40,8 +40,8 @@
 
 #include "layers_msg.h"
 
-static VK_LAYER_DISPATCH_TABLE nextTable;
-static VK_BASE_LAYER_OBJECT *pCurObj;
+static VkLayerDispatchTable nextTable;
+static VkBaseLayerObject *pCurObj;
 static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);
 
 #include "vk_dispatch_table_helper.h"
@@ -148,7 +148,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateGpus(VkInstance instance, uint32_t max
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
     char str[1024];
@@ -243,7 +243,7 @@ void PostCreateDevice(VkResult result, VkDevice* pDevice)
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
     PreCreateDevice(gpu, pCreateInfo);
@@ -261,7 +261,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
 
@@ -273,7 +273,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLa
 {
     char str[1024];
     if (gpu != NULL) {
-        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
         sprintf(str, "At start of layered EnumerateLayers\n");
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
         pCurObj = gpuw;
@@ -386,7 +386,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pS
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetMultiGpuCompatibility(VkPhysicalGpu gpu0, VkPhysicalGpu gpu1, VkGpuCompatibilityInfo* pInfo)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu0;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu0;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
 
@@ -1932,7 +1932,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer)
 
 VK_LAYER_EXPORT VkResult VKAPI vkWsiX11AssociateConnection(VkPhysicalGpu gpu, const VK_WSI_X11_CONNECTION_INFO* pConnectionInfo)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     pCurObj = gpuw;
     loader_platform_thread_once(&tabOnce, initParamChecker);
 
@@ -1966,7 +1966,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkWsiX11QueuePresent(VkQueue queue, const VK_WSI_
 #include "vk_generic_intercept_proc_helper.h"
 VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)
 {
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
     void* addr;
     if (gpu == NULL)
         return NULL;
diff --git a/loader/loader.c b/loader/loader.c
index 855d35fa..d5dcf8d9 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -48,13 +48,6 @@
 // being used:
 #include "loader_platform.h"
 
-struct loader_instance {
-    struct loader_icd *icds;
-    struct loader_instance *next;
-    uint32_t  extension_count;
-    char **extension_names;
-};
-
 struct loader_layers {
     loader_platform_dl_handle lib_handle;
     char name[256];
@@ -68,12 +61,12 @@ struct layer_name_pair {
 struct loader_icd {
     const struct loader_scanned_icds *scanned_icds;
 
-    VK_LAYER_DISPATCH_TABLE *loader_dispatch;
+    VkLayerDispatchTable *loader_dispatch;
     uint32_t layer_count[VK_MAX_PHYSICAL_GPUS];
     struct loader_layers layer_libs[VK_MAX_PHYSICAL_GPUS][MAX_LAYER_LIBRARIES];
-    VK_BASE_LAYER_OBJECT *wrappedGpus[VK_MAX_PHYSICAL_GPUS];
+    VkBaseLayerObject *wrappedGpus[VK_MAX_PHYSICAL_GPUS];
     uint32_t gpu_count;
-    VK_BASE_LAYER_OBJECT *gpus;
+    VkBaseLayerObject *gpus;
 
     struct loader_icd *next;
 };
@@ -517,7 +510,7 @@ static void layer_lib_scan(void)
     loader.layer_scanned = true;
 }
 
-static void loader_init_dispatch_table(VK_LAYER_DISPATCH_TABLE *tab, PFN_vkGetProcAddr fpGPA, VkPhysicalGpu gpu)
+static void loader_init_dispatch_table(VkLayerDispatchTable *tab, PFN_vkGetProcAddr fpGPA, VkPhysicalGpu gpu)
 {
     loader_initialize_dispatch_table(tab, fpGPA, gpu);
 
@@ -525,7 +518,7 @@ static void loader_init_dispatch_table(VK_LAYER_DISPATCH_TABLE *tab, PFN_vkGetPr
         tab->EnumerateLayers = vkEnumerateLayers;
 }
 
-static struct loader_icd * loader_get_icd(const VK_BASE_LAYER_OBJECT *gpu, uint32_t *gpu_index)
+extern struct loader_icd * loader_get_icd(const VkBaseLayerObject *gpu, uint32_t *gpu_index)
 {
     for (struct loader_instance *inst = loader.instances; inst; inst = inst->next) {
         for (struct loader_icd *icd = inst->icds; icd; icd = icd->next) {
@@ -716,7 +709,7 @@ static uint32_t loader_get_layer_env(struct loader_icd *icd, uint32_t gpu_index,
     return count;
 }
 
-static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, const VkDeviceCreateInfo* pCreateInfo, struct layer_name_pair **ppLayerNames)
+static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index, uint32_t ext_count, const char *const* ext_names, struct layer_name_pair **ppLayerNames)
 {
     static struct layer_name_pair layerNames[MAX_LAYER_LIBRARIES];
     const char *lib_name = NULL;
@@ -726,8 +719,8 @@ static uint32_t loader_get_layer_libs(struct loader_icd *icd, uint32_t gpu_index
     /* Load any layers specified in the environment first */
     count = loader_get_layer_env(icd, gpu_index, layerNames);
 
-    for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
-        const char *pExtName = pCreateInfo->ppEnabledExtensionNames[i];
+    for (uint32_t i = 0; i < ext_count; i++) {
+        const char *pExtName = ext_names[i];
 
         if (find_layer_extension(icd, gpu_index, pExtName, &lib_name) == VK_SUCCESS) {
             uint32_t len;
@@ -790,29 +783,28 @@ static void loader_deactivate_layer(const struct loader_instance *instance)
     }
 }
 
-extern uint32_t loader_activate_layers(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo)
+extern uint32_t loader_activate_layers(struct loader_icd *icd, uint32_t gpu_index, uint32_t ext_count, const char *const* ext_names)
 {
-    uint32_t gpu_index;
     uint32_t count;
+    VkBaseLayerObject *gpu;
     struct layer_name_pair *pLayerNames;
-    struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index);
-
     if (!icd)
         return 0;
     assert(gpu_index < VK_MAX_PHYSICAL_GPUS);
 
+    gpu = icd->gpus + gpu_index;
     /* activate any layer libraries */
     if (!loader_layers_activated(icd, gpu_index)) {
-        VK_BASE_LAYER_OBJECT *gpuObj = (VK_BASE_LAYER_OBJECT *) gpu;
-        VK_BASE_LAYER_OBJECT *nextGpuObj, *baseObj = gpuObj->baseObject;
+        VkBaseLayerObject *gpuObj = gpu;
+        VkBaseLayerObject *nextGpuObj, *baseObj = gpuObj->baseObject;
         PFN_vkGetProcAddr nextGPA = vkGetProcAddr;
 
-        count = loader_get_layer_libs(icd, gpu_index, pCreateInfo, &pLayerNames);
+        count = loader_get_layer_libs(icd, gpu_index, ext_count, ext_names, &pLayerNames);
         if (!count)
             return 0;
         loader_init_layer_libs(icd, gpu_index, pLayerNames, count);
 
-        icd->wrappedGpus[gpu_index] = malloc(sizeof(VK_BASE_LAYER_OBJECT) * icd->layer_count[gpu_index]);
+        icd->wrappedGpus[gpu_index] = malloc(sizeof(VkBaseLayerObject) * icd->layer_count[gpu_index]);
         if (! icd->wrappedGpus[gpu_index])
                 loader_log(VK_DBG_MSG_ERROR, 0, "Failed to malloc Gpu objects for layer");
         for (int32_t i = icd->layer_count[gpu_index] - 1; i >= 0; i--) {
@@ -834,8 +826,8 @@ extern uint32_t loader_activate_layers(VkPhysicalGpu gpu, const VkDeviceCreateIn
             if (i == 0) {
                 loader_init_dispatch_table(icd->loader_dispatch + gpu_index, nextGPA, gpuObj);
                 //Insert the new wrapped objects into the list with loader object at head
-                ((VK_BASE_LAYER_OBJECT *) gpu)->nextObject = gpuObj;
-                ((VK_BASE_LAYER_OBJECT *) gpu)->pGPA = nextGPA;
+                gpu->nextObject = gpuObj;
+                gpu->pGPA = nextGPA;
                 gpuObj = icd->wrappedGpus[gpu_index] + icd->layer_count[gpu_index] - 1;
                 gpuObj->nextObject = baseObj;
                 gpuObj->pGPA = icd->scanned_icds->GetProcAddr;
@@ -845,7 +837,7 @@ extern uint32_t loader_activate_layers(VkPhysicalGpu gpu, const VkDeviceCreateIn
     }
     else {
         //make sure requested Layers matches currently activated Layers
-        count = loader_get_layer_libs(icd, gpu_index, pCreateInfo, &pLayerNames);
+        count = loader_get_layer_libs(icd, gpu_index, ext_count, ext_names, &pLayerNames);
         for (uint32_t i = 0; i < count; i++) {
             if (strcmp(icd->layer_libs[gpu_index][i].name, pLayerNames[i].layer_name)) {
                 loader_log(VK_DBG_MSG_ERROR, 0, "Layers activated != Layers requested");
@@ -986,7 +978,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateGpus(
     icd = ptr_instance->icds;
     while (icd) {
         VkPhysicalGpu gpus[VK_MAX_PHYSICAL_GPUS];
-        VK_BASE_LAYER_OBJECT * wrapped_gpus;
+        VkBaseLayerObject * wrapped_gpus;
         PFN_vkGetProcAddr get_proc_addr = icd->scanned_icds->GetProcAddr;
         uint32_t n, max = maxGpus - count;
 
@@ -998,12 +990,12 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateGpus(
                                                max, &n,
                                                gpus);
         if (res == VK_SUCCESS && n) {
-            wrapped_gpus = (VK_BASE_LAYER_OBJECT*) malloc(n *
-                                        sizeof(VK_BASE_LAYER_OBJECT));
+            wrapped_gpus = (VkBaseLayerObject*) malloc(n *
+                                        sizeof(VkBaseLayerObject));
             icd->gpus = wrapped_gpus;
             icd->gpu_count = n;
-            icd->loader_dispatch = (VK_LAYER_DISPATCH_TABLE *) malloc(n *
-                                        sizeof(VK_LAYER_DISPATCH_TABLE));
+            icd->loader_dispatch = (VkLayerDispatchTable *) malloc(n *
+                                        sizeof(VkLayerDispatchTable));
             for (unsigned int i = 0; i < n; i++) {
                 (wrapped_gpus + i)->baseObject = gpus[i];
                 (wrapped_gpus + i)->pGPA = get_proc_addr;
@@ -1019,8 +1011,8 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateGpus(
                     assert(0);
                 }
 
-                const VK_LAYER_DISPATCH_TABLE **disp;
-                disp = (const VK_LAYER_DISPATCH_TABLE **) gpus[i];
+                const VkLayerDispatchTable **disp;
+                disp = (const VkLayerDispatchTable **) gpus[i];
                 *disp = icd->loader_dispatch + i;
             }
 
@@ -1044,8 +1036,8 @@ LOADER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char * pName)
     if (gpu == NULL) {
         return NULL;
     }
-    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;
-    VK_LAYER_DISPATCH_TABLE * disp_table = * (VK_LAYER_DISPATCH_TABLE **) gpuw->baseObject;
+    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
+    VkLayerDispatchTable * disp_table = * (VkLayerDispatchTable **) gpuw->baseObject;
     void *addr;
 
     if (disp_table == NULL)
@@ -1064,7 +1056,7 @@ LOADER_EXPORT void * VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char * pName)
 LOADER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char *pExtName)
 {
     uint32_t gpu_index;
-    struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index);
+    struct loader_icd *icd = loader_get_icd((const VkBaseLayerObject *) gpu, &gpu_index);
 
     if (!icd)
         return VK_ERROR_UNAVAILABLE;
@@ -1077,7 +1069,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLaye
     uint32_t gpu_index;
     size_t count = 0;
     char *lib_name;
-    struct loader_icd *icd = loader_get_icd((const VK_BASE_LAYER_OBJECT *) gpu, &gpu_index);
+    struct loader_icd *icd = loader_get_icd((const VkBaseLayerObject *) gpu, &gpu_index);
     loader_platform_dl_handle handle;
     PFN_vkEnumerateLayers fpEnumerateLayers;
     char layer_buf[16][256];
diff --git a/loader/loader.h b/loader/loader.h
index 2967322b..77c50c9a 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -67,14 +67,22 @@ static inline void loader_init_data(void *obj, const void *data)
 
 static inline void *loader_unwrap_gpu(VkPhysicalGpu *gpu)
 {
-    const VK_BASE_LAYER_OBJECT *wrap = (const VK_BASE_LAYER_OBJECT *) *gpu;
+    const VkBaseLayerObject *wrap = (const VkBaseLayerObject *) *gpu;
 
     *gpu = (VkPhysicalGpu) wrap->nextObject;
 
     return loader_get_data(wrap->baseObject);
 }
 
-extern uint32_t loader_activate_layers(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo);
+struct loader_instance {
+    struct loader_icd *icds;
+    struct loader_instance *next;
+    uint32_t  extension_count;
+    char **extension_names;
+};
+
+extern uint32_t loader_activate_layers(struct loader_icd *icd, uint32_t gpu_index, uint32_t ext_count, const char *const* ext_names);
+extern struct loader_icd * loader_get_icd(const VkBaseLayerObject *gpu, uint32_t *gpu_index);
 #define MAX_LAYER_LIBRARIES 64
 
 #endif /* LOADER_H */
diff --git a/vk-generate.py b/vk-generate.py
index 6591b1c9..c25f254b 100755
--- a/vk-generate.py
+++ b/vk-generate.py
@@ -154,15 +154,19 @@ class LoaderEntrypointsSubcommand(Subcommand):
             func.append("{")
 
             # declare local variables
-            func.append("    const VK_LAYER_DISPATCH_TABLE *disp;")
+            func.append("    const VkLayerDispatchTable *disp;")
             if proto.ret != 'void' and obj_setup:
                 func.append("    VkResult res;")
             func.append("")
 
             # active layers before dispatching CreateDevice
             if proto.name == "CreateDevice":
-                func.append("    loader_activate_layers(%s, %s);" %
-                        (proto.params[0].name, proto.params[1].name))
+                func.append("    {")
+                func.append("        uint32_t gpu_index;")
+                func.append("        struct loader_icd *icd = loader_get_icd((const VkBaseLayerObject *) gpu, &gpu_index);")
+                func.append("        loader_activate_layers((void *) icd, gpu_index, %s->extensionCount, %s->ppEnabledExtensionNames);"
+                        % (proto.params[1].name, proto.params[1].name))
+                func.append("    }")
                 func.append("")
 
             # get dispatch table and unwrap GPUs
@@ -235,7 +239,7 @@ class DispatchTableOpsSubcommand(Subcommand):
         stmts.append("#endif")
 
         func = []
-        func.append("static inline void %s_initialize_dispatch_table(VK_LAYER_DISPATCH_TABLE *table,"
+        func.append("static inline void %s_initialize_dispatch_table(VkLayerDispatchTable *table,"
                 % self.prefix)
         func.append("%s                                              PFN_vkGetProcAddr gpa,"
                 % (" " * len(self.prefix)))
@@ -258,7 +262,7 @@ class DispatchTableOpsSubcommand(Subcommand):
         lookups.append("#endif")
 
         func = []
-        func.append("static inline void *%s_lookup_dispatch_table(const VK_LAYER_DISPATCH_TABLE *table,"
+        func.append("static inline void *%s_lookup_dispatch_table(const VkLayerDispatchTable *table,"
                 % self.prefix)
         func.append("%s                                           const char *name)"
                 % (" " * len(self.prefix)))
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 266319c5..c97bedff 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -199,6 +199,28 @@ class Subcommand(object):
         ges_body.append('VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)')
         ges_body.append('{')
         ges_body.append('    VkResult result;')
+        ges_body.append('    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;')
+        ges_body.append('')
+        ges_body.append('    /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */')
+        ges_body.append('    if (!strncmp(pExtName, "%s", strlen("%s")))' % (layer, layer))
+        ges_body.append('    {')
+        ges_body.append('        result = VK_SUCCESS;')
+        ges_body.append('    } else if (nextTable.GetExtensionSupport != NULL)')
+        ges_body.append('    {')
+        ges_body.append('        result = nextTable.GetExtensionSupport((VkPhysicalGpu)gpuw->nextObject, pExtName);')
+        ges_body.append('    } else')
+        ges_body.append('    {')
+        ges_body.append('        result = VK_ERROR_INVALID_EXTENSION;')
+        ges_body.append('    }')
+        ges_body.append('    return result;')
+        ges_body.append('}')
+        return "\n".join(ges_body)
+
+    def _gen_layer_get_extension_support(self, layer="Generic"):
+        ges_body = []
+        ges_body.append('VK_LAYER_EXPORT VkResult VKAPI vkGetExtensionSupport(VkPhysicalGpu gpu, const char* pExtName)')
+        ges_body.append('{')
+        ges_body.append('    VkResult result;')
         ges_body.append('    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) gpu;')
         ges_body.append('')
         ges_body.append('    /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */')
@@ -296,6 +318,20 @@ class Subcommand(object):
         exts.append('    return VK_SUCCESS;')
         exts.append('}')
 
+    def _generate_layer_gpa_function(self, extensions=[]):
+        func_body = []
+        func_body.append("VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcName)\n"
+                         "{\n"
+                         "    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;\n"
+                         "    void* addr;\n"
+                         "    if (gpu == NULL)\n"
+                         "        return NULL;\n"
+                         "    pCurObj = gpuw;\n"
+                         "    loader_platform_thread_once(&tabOnce, init%s);\n\n"
+                         "    addr = layer_intercept_proc(funcName);\n"
+                         "    if (addr)\n"
+                         "        return addr;" % self.layer_name)
+
         return "\n".join(exts)
 
     def _generate_layer_gpa_function(self, extensions=[]):
@@ -394,7 +430,7 @@ class LayerDispatchSubcommand(Subcommand):
 
 class GenericLayerSubcommand(Subcommand):
     def generate_header(self):
-        return '#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include "loader_platform.h"\n#include "vkLayer.h"\n//The following is #included again to catch certain OS-specific functions being used:\n#include "loader_platform.h"\n\n#include "layers_config.h"\n#include "layers_msg.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;\n\nstatic LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);'
+        return '#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include "loader_platform.h"\n#include "vkLayer.h"\n//The following is #included again to catch certain OS-specific functions being used:\n#include "loader_platform.h"\n\n#include "layers_config.h"\n#include "layers_msg.h"\n\nstatic VkLayerDispatchTable nextTable;\nstatic VkBaseLayerObject *pCurObj;\n\nstatic LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);'
 
     def generate_intercept(self, proto, qual):
         if proto.name in [ 'DbgRegisterMsgCallback', 'DbgUnregisterMsgCallback' , 'GetExtensionSupport']:
@@ -416,7 +452,7 @@ class GenericLayerSubcommand(Subcommand):
                      '{\n'
                      '    char str[1024];\n'
                      '    if (gpu != NULL) {\n'
-                     '        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                     '        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
                      '        sprintf(str, "At start of layered %s\\n");\n'
                      '        layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpu, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '        pCurObj = gpuw;\n'
@@ -446,7 +482,7 @@ class GenericLayerSubcommand(Subcommand):
             funcs.append('%s%s\n'
                      '{\n'
                      '    char str[1024];'
-                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
                      '    sprintf(str, "At start of layered %s\\n");\n'
                      '    layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, gpuw, 0, 0, (char *) "GENERIC", (char *) str);\n'
                      '    pCurObj = gpuw;\n'
@@ -508,8 +544,8 @@ class APIDumpSubcommand(Subcommand):
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
         header_txt.append('')
-        header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;')
-        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;')
+        header_txt.append('static VkLayerDispatchTable nextTable;')
+        header_txt.append('static VkBaseLayerObject *pCurObj;')
         header_txt.append('')
         header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
         header_txt.append('static int printLockInitialized = 0;')
@@ -702,7 +738,7 @@ class APIDumpSubcommand(Subcommand):
                      '{\n'
                      '    using namespace StreamControl;\n'
                      '    if (gpu != NULL) {\n'
-                     '        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                     '        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
                      '        pCurObj = gpuw;\n'
                      '        loader_platform_thread_once(&tabOnce, init%s);\n'
                      '        %snextTable.%s;\n'
@@ -721,7 +757,7 @@ class APIDumpSubcommand(Subcommand):
             c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                          '{\n'
-                         '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                         '    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
                          '    VkResult result;\n'
                          '    /* This entrypoint is NOT going to init its own dispatch table since loader calls here early */\n'
                          '    if (!strncmp(pExtName, "%s", strlen("%s")))\n'
@@ -750,6 +786,18 @@ class APIDumpSubcommand(Subcommand):
             funcs.append('%s%s\n'
                      '{\n'
                      '    using namespace StreamControl;\n'
+                     '    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
+                     '    pCurObj = gpuw;\n'
+                     '    loader_platform_thread_once(&tabOnce, init%s);\n'
+                     '    %snextTable.%s;\n'
+                     '    %s%s%s\n'
+                     '%s'
+                     '}' % (qual, decl, ret_val, proto.c_call(), f_open, log_func, f_close, stmt))
+        else:
+            c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1)
+            funcs.append('%s%s\n'
+                     '{\n'
+                     '    using namespace StreamControl;\n'
                      '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
                      '    pCurObj = gpuw;\n'
                      '    loader_platform_thread_once(&tabOnce, init%s);\n'
@@ -777,7 +825,7 @@ class APIDumpSubcommand(Subcommand):
 #        header_txt.append('#include "vkLayer.h"\n#include "vk_struct_string_helper_no_addr_cpp.h"\n')
 #        header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
 #        header_txt.append('#include "loader_platform.h"')
-#        header_txt.append('static VK_LAYER_DISPATCH_TABLE nextTable;')
+#        header_txt.append('static VkLayerDispatchTable nextTable;')
 #        header_txt.append('static VK_BASE_LAYER_OBJECT *pCurObj;\n')
 #        header_txt.append('static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(tabOnce);')
 #        header_txt.append('static int printLockInitialized = 0;')
@@ -814,7 +862,7 @@ class ObjectTrackerSubcommand(Subcommand):
     def generate_header(self):
         header_txt = []
         header_txt.append('#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include "loader_platform.h"')
-        header_txt.append('#include "object_track.h"\n\nstatic VK_LAYER_DISPATCH_TABLE nextTable;\nstatic VK_BASE_LAYER_OBJECT *pCurObj;')
+        header_txt.append('#include "object_track.h"\n\nstatic VkLayerDispatchTable nextTable;\nstatic VkBaseLayerObject *pCurObj;')
         header_txt.append('// The following is #included again to catch certain OS-specific functions being used:')
         header_txt.append('#include "loader_platform.h"')
         header_txt.append('#include "layers_config.h"')
@@ -1352,7 +1400,7 @@ class ObjectTrackerSubcommand(Subcommand):
             funcs.append('%s%s\n'
                      '{\n'
                      '    if (gpu != NULL) {\n'
-                     '        VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                     '        VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
                      '    %s'
                      '        pCurObj = gpuw;\n'
                      '        loader_platform_thread_once(&tabOnce, init%s);\n'
@@ -1372,7 +1420,7 @@ class ObjectTrackerSubcommand(Subcommand):
             c_call = proto.c_call().replace("(" + proto.params[0].name, "((VkPhysicalGpu)gpuw->nextObject", 1)
             funcs.append('%s%s\n'
                      '{\n'
-                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
                      '    VkResult result;\n'
                      '    /* This entrypoint is NOT going to init its own dispatch table since loader calls this early */\n'
                      '    if (!strncmp(pExtName, "%s", strlen("%s")) ||\n'
@@ -1409,7 +1457,7 @@ class ObjectTrackerSubcommand(Subcommand):
                 gpu_state += '    }\n'
             funcs.append('%s%s\n'
                      '{\n'
-                     '    VK_BASE_LAYER_OBJECT* gpuw = (VK_BASE_LAYER_OBJECT *) %s;\n'
+                     '    VkBaseLayerObject* gpuw = (VkBaseLayerObject *) %s;\n'
                      '%s'
                      '    pCurObj = gpuw;\n'
                      '    loader_platform_thread_once(&tabOnce, init%s);\n'
diff --git a/vulkan.py b/vulkan.py
index 07f431b6..220b4a6e 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -1024,11 +1024,11 @@ def parse_vk_h(filename):
     print("core =", str(ext))
 
     print("")
-    print("typedef struct _VK_LAYER_DISPATCH_TABLE")
+    print("typedef struct VkLayerDispatchTable_")
     print("{")
     for proto in ext.protos:
         print("    vk%sType %s;" % (proto.name, proto.name))
-    print("} VK_LAYER_DISPATCH_TABLE;")
+    print("} VkLayerDispatchTable;")
 
 if __name__ == "__main__":
     parse_vk_h("include/vulkan.h")