vkEnumerateLayers: Update to match upstream

The upstream vulkan.h header removed maxLayerCount parameter
from vkEnumerateLayers. This patch implements that change
for the sample driver and layers.

13 files changed, 63 insertions, 63 deletions

diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 8edacd55..e9f0b76c 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1812,9 +1812,8 @@ ICD_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
 
 ICD_EXPORT VkResult VKAPI vkEnumerateLayers(
     VkPhysicalDevice                            gpu,
-    size_t                                      maxLayerCount,
     size_t                                      maxStringSize,
-    size_t*                                     pOutLayerCount,
+    size_t*                                     pLayerCount,
     char* const*                                pOutLayers,
     void*                                       pReserved)
 {
diff --git a/include/vulkan.h b/include/vulkan.h
index b46fdc46..28f15096 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -2133,7 +2133,7 @@ typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, co
 typedef VkResult (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
 typedef VkResult (VKAPI *PFN_vkGetGlobalExtensionInfo)(VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData);
 typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionInfo)(VkPhysicalDevice gpu, VkExtensionInfoType infoType, uint32_t extensionIndex, size_t* pDataSize, void* pData);
-typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved);
+typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved);
 typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue);
 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkQueueAddMemReferences)(VkQueue queue, uint32_t count, const VkDeviceMemory* pMems);
@@ -2296,7 +2296,6 @@ VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
 
 VkResult VKAPI vkEnumerateLayers(
     VkPhysicalDevice                            physicalDevice,
-    size_t                                      maxLayerCount,
     size_t                                      maxStringSize,
     size_t*                                     pLayerCount,
     char* const*                                pOutLayers,
diff --git a/layers/basic.cpp b/layers/basic.cpp
index b7ad6b7c..64964f34 100644
--- a/layers/basic.cpp
+++ b/layers/basic.cpp
@@ -135,18 +135,18 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format,
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
 {
     if (gpu != NULL)
     {
         VkLayerDispatchTable* pTable = initLayerTable((const VkBaseLayerObject *) gpu);
 
         printf("At start of wrapped vkEnumerateLayers() call w/ gpu: %p\n", gpu);
-        VkResult result = pTable->EnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        VkResult result = pTable->EnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
         return result;
     } else
     {
-        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pReserved == NULL)
+        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pReserved == NULL)
             return VK_ERROR_INVALID_POINTER;
 
         // Example of a layer that is only compatible with Intel's GPUs
@@ -158,11 +158,11 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t ma
         fpGetGpuInfo((VkPhysicalDevice) gpuw->nextObject, VK_PHYSICAL_DEVICE_INFO_TYPE_PROPERTIES, &dataSize, &gpuProps);
         if (gpuProps.vendorId == 0x8086)
         {
-            *pOutLayerCount = 1;
+            *pLayerCount = 1;
             strncpy((char *) pOutLayers[0], "Basic", maxStringSize);
         } else
         {
-            *pOutLayerCount = 0;
+            *pLayerCount = 0;
         }
         return VK_SUCCESS;
     }
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index aae865b8..aad27451 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -1519,19 +1519,19 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo(
     return VK_SUCCESS;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
 {
     if (gpu != NULL)
     {
         pCurObj = (VkBaseLayerObject *) gpu;
         loader_platform_thread_once(&g_initOnce, initDrawState);
-        VkResult result = nextTable.EnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        VkResult result = nextTable.EnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
         return result;
     } else {
-        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
+        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
             return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
-        *pOutLayerCount = 1;
+        *pLayerCount = 1;
         strncpy((char *) pOutLayers[0], "DrawState", maxStringSize);
         return VK_SUCCESS;
     }
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 81a2b588..e7afe57a 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -542,22 +542,22 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalGpu gpu, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
 {
     if (gpu != NULL) {
         VkBaseLayerObject* gpuw = (VkBaseLayerObject *) gpu;
         loader_platform_thread_lock_mutex(&objLock);
-    ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
-    loader_platform_thread_unlock_mutex(&objLock);
+        ll_increment_use_count((void*)gpu, VK_OBJECT_TYPE_PHYSICAL_GPU);
+        loader_platform_thread_unlock_mutex(&objLock);
         pCurObj = gpuw;
         loader_platform_thread_once(&tabOnce, initGlaveSnapshot);
-        VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
-            return result;
+        VkResult result = nextTable.EnumerateLayers((VkPhysicalGpu)gpuw->nextObject, maxStringSize, pLayerCount, pOutLayers, pReserved);
+        return result;
     } else {
-        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
+        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
             return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
-        *pOutLayerCount = 1;
+        *pLayerCount = 1;
         strncpy((char *) pOutLayers[0], LAYER_NAME_STR, maxStringSize);
         return VK_SUCCESS;
     }
diff --git a/layers/glsl_compiler.c b/layers/glsl_compiler.c
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/layers/glsl_compiler.c
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 6f5eb39f..45bea6f5 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -951,22 +951,22 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo(
     return VK_SUCCESS;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount,
-    size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu,
+    size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
 {
         if (gpu != NULL)
     {
         pCurObj = (VkBaseLayerObject *)  gpu;
         loader_platform_thread_once(&g_initOnce, initMemTracker);
-        VkResult result = nextTable.EnumerateLayers(gpu, maxLayerCount,
-            maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        VkResult result = nextTable.EnumerateLayers(gpu,
+            maxStringSize, pLayerCount, pOutLayers, pReserved);
         return result;
     } else
     {
-        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
+        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
             return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
-        *pOutLayerCount = 1;
+        *pLayerCount = 1;
         strncpy((char *) pOutLayers[0], "MemTracker", maxStringSize);
         return VK_SUCCESS;
     }
diff --git a/layers/multi.cpp b/layers/multi.cpp
index e70b6383..1640dc6f 100644
--- a/layers/multi.cpp
+++ b/layers/multi.cpp
@@ -97,16 +97,16 @@ VK_LAYER_EXPORT VkResult VKAPI multi1StorePipeline(VkDevice device, VkPipeline p
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI multi1EnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize,
-                                                         size_t* pOutLayerCount, char* const* pOutLayers,
+VK_LAYER_EXPORT VkResult VKAPI multi1EnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize,
+                                                         size_t* pLayerCount, char* const* pOutLayers,
                                                          void* pReserved)
 {
     if (gpu == NULL)
-        return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        return vkEnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
 
     VkLayerDispatchTable* pTable = tableMap1[gpu];
     printf("At start of multi1 layer vkEnumerateLayers()\n");
-    VkResult result = pTable->EnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+    VkResult result = pTable->EnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
     printf("Completed multi1 layer vkEnumerateLayers()\n");
     return result;
 }
@@ -194,17 +194,17 @@ VK_LAYER_EXPORT VkResult VKAPI multi2BeginCommandBuffer(VkCmdBuffer cmdBuffer, c
 
 }
 
-VK_LAYER_EXPORT VkResult VKAPI multi2EnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize,
-                                                         size_t* pOutLayerCount, char* const* pOutLayers,
+VK_LAYER_EXPORT VkResult VKAPI multi2EnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize,
+                                                         size_t* pLayerCount, char* const* pOutLayers,
                                                          void* pReserved)
 {
     if (gpu == NULL)
-        return vkEnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        return vkEnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
 
     VkLayerDispatchTable* pTable = tableMap2[gpu];
 
     printf("At start of multi2 layer vkEnumerateLayers()\n");
-    VkResult result = pTable->EnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+    VkResult result = pTable->EnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
     printf("Completed multi2 layer vkEnumerateLayers()\n");
     return result;
 }
@@ -234,16 +234,16 @@ VK_LAYER_EXPORT void * VKAPI multi2GetProcAddr(VkPhysicalDevice gpu, const char*
 }
 
 /********************************* Common functions ********************************/
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize,
-                                                      size_t* pOutLayerCount, char* const* pOutLayers,
-                                                      void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize,
+                                                 size_t* pLayerCount, char* const* pOutLayers,
+                                                 void* pReserved)
 {
-    if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pOutLayers[1] == NULL || pReserved == NULL)
+    if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pOutLayers[1] == NULL || pReserved == NULL)
         return VK_ERROR_INVALID_POINTER;
 
-    if (maxLayerCount < 2)
+    if (*pLayerCount < 2)
         return VK_ERROR_INITIALIZATION_FAILED;
-    *pOutLayerCount = 2;
+    *pLayerCount = 2;
     strncpy((char *) pOutLayers[0], "multi1", maxStringSize);
     strncpy((char *) pOutLayers[1], "multi2", maxStringSize);
     return VK_SUCCESS;
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 74d8582a..3171baf2 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -308,7 +308,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
 {
     char str[1024];
     if (gpu != NULL) {
@@ -316,16 +316,16 @@ VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t ma
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
         pCurObj = (VkBaseLayerObject *) gpu;
         loader_platform_thread_once(&tabOnce, initParamChecker);
-        VkResult result = nextTable.EnumerateLayers(gpu, maxLayerCount, maxStringSize, pOutLayerCount, pOutLayers, pReserved);
+        VkResult result = nextTable.EnumerateLayers(gpu, maxStringSize, pLayerCount, pOutLayers, pReserved);
         sprintf(str, "Completed layered EnumerateLayers\n");
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, nullptr, 0, 0, "PARAMCHECK", str);
         fflush(stdout);
         return result;
     } else {
-        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
+        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)
             return VK_ERROR_INVALID_POINTER;
         // This layer compatible with all GPUs
-        *pOutLayerCount = 1;
+        *pLayerCount = 1;
         strncpy(pOutLayers[0], "ParamChecker", maxStringSize);
         return VK_SUCCESS;
     }
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index cc6bb3e1..28e0fddc 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -161,14 +161,14 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDevi
 }
 
 
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+VK_LAYER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice physicalDevice, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
 {
-    if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pOutLayers[1] == NULL || pReserved == NULL)
+    if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL || pOutLayers[1] == NULL || pReserved == NULL)
         return VK_ERROR_INVALID_POINTER;
 
-    if (maxLayerCount < 1)
+    if (*pLayerCount < 1)
         return VK_ERROR_INITIALIZATION_FAILED;
-    *pOutLayerCount = 1;
+    *pLayerCount = 1;
     strncpy((char *) pOutLayers[0], "ShaderChecker", maxStringSize);
     return VK_SUCCESS;
 }
diff --git a/loader/loader.c b/loader/loader.c
index de296fa9..3325a109 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -1368,8 +1368,9 @@ LOADER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo(
     return VK_SUCCESS;
 }
 
-LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved)
+LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxStringSize, size_t* pLayerCount, char* const* pOutLayers, void* pReserved)
 {
+    size_t maxLayerCount;
     uint32_t gpu_index;
     size_t count = 0;
     char *lib_name;
@@ -1379,9 +1380,11 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxL
     char layer_buf[16][256];
     char * layers[16];
 
-    if (pOutLayerCount == NULL || pOutLayers == NULL)
+    if (pLayerCount == NULL || pOutLayers == NULL)
         return VK_ERROR_INVALID_POINTER;
 
+    maxLayerCount = *pLayerCount;
+
     if (!icd)
         return VK_ERROR_UNAVAILABLE;
 
@@ -1417,11 +1420,11 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxL
             count++;
             free(cpyStr);
         } else {
-            size_t cnt;
+            size_t cnt = 16; /* only allow 16 layers, for now */
             uint32_t n;
             VkResult res;
             n = (uint32_t) ((maxStringSize < 256) ? maxStringSize : 256);
-            res = fpEnumerateLayers((VkPhysicalDevice) NULL, 16, n, &cnt, layers, (char *) icd->gpus + gpu_index);
+            res = fpEnumerateLayers((VkPhysicalDevice) NULL, n, &cnt, layers, (char *) icd->gpus + gpu_index);
             loader_platform_close_library(handle);
             if (res != VK_SUCCESS)
                 continue;
@@ -1436,7 +1439,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateLayers(VkPhysicalDevice gpu, size_t maxL
         }
     }
 
-    *pOutLayerCount = count;
+    *pLayerCount = count;
 
     return VK_SUCCESS;
 }
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index fe76533a..e97243b1 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -492,10 +492,10 @@ class GenericLayerSubcommand(Subcommand):
                      '        fflush(stdout);\n'
                      '    %s'
                      '    } else {\n'
-                     '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
+                     '        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
                      '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
-                     '        *pOutLayerCount = 1;\n'
+                     '        *pLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
                      '        return VK_SUCCESS;\n'
                      '    }\n'
@@ -753,10 +753,10 @@ class APIDumpSubcommand(Subcommand):
                      '        %s    %s    %s\n'
                      '    %s'
                      '    } else {\n'
-                     '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
+                     '        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
                      '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
-                     '        *pOutLayerCount = 1;\n'
+                     '        *pLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
                      '        return VK_SUCCESS;\n'
                      '    }\n'
@@ -1209,10 +1209,10 @@ class ObjectTrackerSubcommand(Subcommand):
                      '    %s%s'
                      '    %s'
                      '    } else {\n'
-                     '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
+                     '        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
                      '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
-                     '        *pOutLayerCount = 1;\n'
+                     '        *pLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
                      '        return VK_SUCCESS;\n'
                      '    }\n'
@@ -1349,10 +1349,10 @@ class ThreadingSubcommand(Subcommand):
                      '        fflush(stdout);\n'
                      '    %s'
                      '    } else {\n'
-                     '        if (pOutLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
+                     '        if (pLayerCount == NULL || pOutLayers == NULL || pOutLayers[0] == NULL)\n'
                      '            return VK_ERROR_INVALID_POINTER;\n'
                      '        // This layer compatible with all GPUs\n'
-                     '        *pOutLayerCount = 1;\n'
+                     '        *pLayerCount = 1;\n'
                      '        strncpy((char *) pOutLayers[0], "%s", maxStringSize);\n'
                      '        return VK_SUCCESS;\n'
                      '    }\n'
diff --git a/vulkan.py b/vulkan.py
index d9a07756..e77a662f 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -262,9 +262,8 @@ core = Extension(
 
         Proto("VkResult", "EnumerateLayers",
             [Param("VkPhysicalDevice", "gpu"),
-             Param("size_t", "maxLayerCount"),
              Param("size_t", "maxStringSize"),
-             Param("size_t*", "pOutLayerCount"),
+             Param("size_t*", "pLayerCount"),
              Param("char* const*", "pOutLayers"),
              Param("void*", "pReserved")]),