bug 14892: 'count' parameters and members named inconsistently in many cases (WIP)

s/waitSemCount/waitSemaphoreCount/g
s/signalSemCount/signalSemaphoreCount/g
s/cmdBufferCount/commandBufferCount/g
s/queueFamilyCount/queueFamilyIndexCount/g
s/layerCount/enabledLayerNameCount/g
s/extensionCount/enabledExtensionNameCount/g

https://cvs.khronos.org/bugzilla/show_bug.cgi?id=14892

4 files changed, 74 insertions, 74 deletions

diff --git a/loader/debug_report.c b/loader/debug_report.c
index 00069b1f..d8d34503 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -59,7 +59,7 @@ void debug_report_create_instance(
 {
     ptr_instance->debug_report_enabled = false;
 
-    for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_DEBUG_REPORT_EXTENSION_NAME) == 0) {
             ptr_instance->debug_report_enabled = true;
             return;
diff --git a/loader/loader.c b/loader/loader.c
index 50b1dcda..6b06b311 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -2262,7 +2262,7 @@ VkResult loader_enable_instance_layers(
     err = loader_add_layer_names_to_list(
                 inst,
                 &inst->activated_layer_list,
-                pCreateInfo->layerCount,
+                pCreateInfo->enabledLayerNameCount,
                 pCreateInfo->ppEnabledLayerNames,
                 instance_layers);
 
@@ -2398,7 +2398,7 @@ static VkResult loader_enable_device_layers(
     err = loader_add_layer_names_to_list(
                 inst,
                 &dev->activated_layer_list,
-                pCreateInfo->layerCount,
+                pCreateInfo->enabledLayerNameCount,
                 pCreateInfo->ppEnabledLayerNames,
                 device_layers);
 
@@ -2526,7 +2526,7 @@ VkResult loader_validate_instance_extensions(
     VkExtensionProperties *extension_prop;
     struct loader_layer_properties *layer_prop;
 
-    for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         extension_prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[i],
                                                 icd_exts);
 
@@ -2537,7 +2537,7 @@ VkResult loader_validate_instance_extensions(
         extension_prop = NULL;
 
         /* Not in global list, search layer extension lists */
-        for (uint32_t j = 0; j < pCreateInfo->layerCount; j++) {
+        for (uint32_t j = 0; j < pCreateInfo->enabledLayerNameCount; j++) {
             layer_prop = loader_get_layer_property(pCreateInfo->ppEnabledLayerNames[i],
                                             instance_layer);
             if (!layer_prop) {
@@ -2572,7 +2572,7 @@ VkResult loader_validate_device_extensions(
     VkExtensionProperties *extension_prop;
     struct loader_layer_properties *layer_prop;
 
-    for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i];
         extension_prop = get_extension_property(extension_name,
                                                 &icd->device_extension_cache[gpu_index]);
@@ -2582,7 +2582,7 @@ VkResult loader_validate_device_extensions(
         }
 
         /* Not in global list, search layer extension lists */
-        for (uint32_t j = 0; j < pCreateInfo->layerCount; j++) {
+        for (uint32_t j = 0; j < pCreateInfo->enabledLayerNameCount; j++) {
             const char *layer_name = pCreateInfo->ppEnabledLayerNames[j];
             layer_prop = loader_get_layer_property(layer_name,
                                   device_layer);
@@ -2623,7 +2623,7 @@ VkResult VKAPI loader_CreateInstance(
     bool success;
 
     icd_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
-    icd_create_info.layerCount = 0;
+    icd_create_info.enabledLayerNameCount = 0;
     icd_create_info.ppEnabledLayerNames = NULL;
     icd_create_info.pAllocCb = pCreateInfo->pAllocCb;
     icd_create_info.pAppInfo = pCreateInfo->pAppInfo;
@@ -2636,7 +2636,7 @@ VkResult VKAPI loader_CreateInstance(
      * library could support a layer, but it would be
      * independent of the actual ICD, just in the same library.
      */
-    filtered_extension_names = loader_stack_alloc(pCreateInfo->extensionCount * sizeof(char *));
+    filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionNameCount * sizeof(char *));
     if (!filtered_extension_names) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -2645,13 +2645,13 @@ VkResult VKAPI loader_CreateInstance(
     for (uint32_t i = 0; i < ptr_instance->icd_libs.count; i++) {
         icd = loader_icd_add(ptr_instance, &ptr_instance->icd_libs.list[i]);
         if (icd) {
-            icd_create_info.extensionCount = 0;
-            for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+            icd_create_info.enabledExtensionNameCount = 0;
+            for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
                 prop = get_extension_property(pCreateInfo->ppEnabledExtensionNames[i],
                                               &ptr_instance->ext_list);
                 if (prop) {
-                    filtered_extension_names[icd_create_info.extensionCount] = (char *) pCreateInfo->ppEnabledExtensionNames[i];
-                    icd_create_info.extensionCount++;
+                    filtered_extension_names[icd_create_info.enabledExtensionNameCount] = (char *) pCreateInfo->ppEnabledExtensionNames[i];
+                    icd_create_info.enabledExtensionNameCount++;
                 }
             }
 
@@ -2846,14 +2846,14 @@ void VKAPI loader_GetPhysicalDeviceProperties(
 
 void VKAPI loader_GetPhysicalDeviceQueueFamilyProperties (
         VkPhysicalDevice                        gpu,
-        uint32_t*                               pCount,
+        uint32_t*                               pQueueFamilyPropertyCount,
         VkQueueFamilyProperties*                pProperties)
 {
     uint32_t gpu_index;
     struct loader_icd *icd = loader_get_icd(gpu, &gpu_index);
 
     if (icd->GetPhysicalDeviceQueueFamilyProperties)
-        icd->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pProperties);
+        icd->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount, pProperties);
 }
 
 void VKAPI loader_GetPhysicalDeviceMemoryProperties (
@@ -2949,8 +2949,8 @@ VkResult VKAPI loader_CreateDevice(
     }
 
     /* validate any app enabled layers are available */
-    if (pCreateInfo->layerCount > 0) {
-        res = loader_validate_layers(pCreateInfo->layerCount,
+    if (pCreateInfo->enabledLayerNameCount > 0) {
+        res = loader_validate_layers(pCreateInfo->enabledLayerNameCount,
                 pCreateInfo->ppEnabledLayerNames,
                 &inst->device_layer_list);
         if (res != VK_SUCCESS) {
@@ -2970,7 +2970,7 @@ VkResult VKAPI loader_CreateDevice(
      * library could support a layer, but it would be
      * independent of the actual ICD, just in the same library.
      */
-    filtered_extension_names = loader_stack_alloc(pCreateInfo->extensionCount * sizeof(char *));
+    filtered_extension_names = loader_stack_alloc(pCreateInfo->enabledExtensionNameCount * sizeof(char *));
     if (!filtered_extension_names) {
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -2979,19 +2979,19 @@ VkResult VKAPI loader_CreateDevice(
     memcpy(&device_create_info, pCreateInfo, sizeof(VkDeviceCreateInfo));
 
     /* ICD's do not use layers */
-    device_create_info.layerCount = 0;
+    device_create_info.enabledLayerNameCount = 0;
     device_create_info.ppEnabledLayerNames = NULL;
 
-    device_create_info.extensionCount = 0;
+    device_create_info.enabledExtensionNameCount = 0;
     device_create_info.ppEnabledExtensionNames = (const char * const *) filtered_extension_names;
 
-    for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         const char *extension_name = pCreateInfo->ppEnabledExtensionNames[i];
         VkExtensionProperties *prop = get_extension_property(extension_name,
                                       &icd->device_extension_cache[gpu_index]);
         if (prop) {
-            filtered_extension_names[device_create_info.extensionCount] = (char *) extension_name;
-            device_create_info.extensionCount++;
+            filtered_extension_names[device_create_info.enabledExtensionNameCount] = (char *) extension_name;
+            device_create_info.enabledExtensionNameCount++;
         }
     }
 
@@ -3126,7 +3126,7 @@ LOADER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, cons
 
 LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceExtensionProperties(
     const char*                                 pLayerName,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkExtensionProperties*                      pProperties)
 {
     struct loader_extension_list *global_ext_list=NULL;
@@ -3166,19 +3166,19 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceExtensionProperties(
     }
 
     if (pProperties == NULL) {
-	*pCount = global_ext_list->count;
+	*pPropertyCount = global_ext_list->count;
 	loader_destroy_layer_list(NULL, &instance_layers);
         loader_destroy_ext_list(NULL, &icd_extensions);
         return VK_SUCCESS;
     }
 
-    copy_size = *pCount < global_ext_list->count ? *pCount : global_ext_list->count;
+    copy_size = *pPropertyCount < global_ext_list->count ? *pPropertyCount : global_ext_list->count;
     for (uint32_t i = 0; i < copy_size; i++) {
         memcpy(&pProperties[i],
                &global_ext_list->list[i],
                sizeof(VkExtensionProperties));
     }
-    *pCount = copy_size;
+    *pPropertyCount = copy_size;
     loader_destroy_ext_list(NULL, &icd_extensions);
 
     if (copy_size < global_ext_list->count) {
@@ -3191,7 +3191,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceExtensionProperties(
 }
 
 LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceLayerProperties(
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkLayerProperties*                          pProperties)
 {
 
@@ -3207,16 +3207,16 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceLayerProperties(
     loader_layer_scan(NULL, &instance_layer_list, NULL);
 
     if (pProperties == NULL) {
-        *pCount = instance_layer_list.count;
+        *pPropertyCount = instance_layer_list.count;
         loader_destroy_layer_list(NULL, &instance_layer_list);
         return VK_SUCCESS;
     }
 
-    copy_size = (*pCount < instance_layer_list.count) ? *pCount : instance_layer_list.count;
+    copy_size = (*pPropertyCount < instance_layer_list.count) ? *pPropertyCount : instance_layer_list.count;
     for (uint32_t i = 0; i < copy_size; i++) {
         memcpy(&pProperties[i], &instance_layer_list.list[i].info, sizeof(VkLayerProperties));
     }
-    *pCount = copy_size;
+    *pPropertyCount = copy_size;
     loader_destroy_layer_list(NULL, &instance_layer_list);
 
     if (copy_size < instance_layer_list.count) {
@@ -3229,7 +3229,7 @@ LOADER_EXPORT VkResult VKAPI vkEnumerateInstanceLayerProperties(
 VkResult VKAPI loader_EnumerateDeviceExtensionProperties(
         VkPhysicalDevice                        gpu,
         const char*                             pLayerName,
-        uint32_t*                               pCount,
+        uint32_t*                               pPropertyCount,
         VkExtensionProperties*                  pProperties)
 {
     uint32_t gpu_index;
@@ -3254,17 +3254,17 @@ VkResult VKAPI loader_EnumerateDeviceExtensionProperties(
 
     count = (dev_ext_list == NULL) ? 0: dev_ext_list->count;
     if (pProperties == NULL) {
-        *pCount = count;
+        *pPropertyCount = count;
         return VK_SUCCESS;
     }
 
-    copy_size = *pCount < count ? *pCount : count;
+    copy_size = *pPropertyCount < count ? *pPropertyCount : count;
     for (uint32_t i = 0; i < copy_size; i++) {
         memcpy(&pProperties[i],
                &dev_ext_list->list[i],
                sizeof(VkExtensionProperties));
     }
-    *pCount = copy_size;
+    *pPropertyCount = copy_size;
 
     if (copy_size < count) {
         return VK_INCOMPLETE;
@@ -3275,7 +3275,7 @@ VkResult VKAPI loader_EnumerateDeviceExtensionProperties(
 
 VkResult VKAPI loader_EnumerateDeviceLayerProperties(
         VkPhysicalDevice                        gpu,
-        uint32_t*                               pCount,
+        uint32_t*                               pPropertyCount,
         VkLayerProperties*                      pProperties)
 {
     uint32_t copy_size;
@@ -3285,15 +3285,15 @@ VkResult VKAPI loader_EnumerateDeviceLayerProperties(
     uint32_t count = icd->this_instance->device_layer_list.count;
 
     if (pProperties == NULL) {
-        *pCount = count;
+        *pPropertyCount = count;
         return VK_SUCCESS;
     }
 
-    copy_size = (*pCount < count) ? *pCount : count;
+    copy_size = (*pPropertyCount < count) ? *pPropertyCount : count;
     for (uint32_t i = 0; i < copy_size; i++) {
         memcpy(&pProperties[i], &(icd->this_instance->device_layer_list.list[i].info), sizeof(VkLayerProperties));
     }
-    *pCount = copy_size;
+    *pPropertyCount = copy_size;
 
     if (copy_size < count) {
         return VK_INCOMPLETE;
diff --git a/loader/trampoline.c b/loader/trampoline.c
index 3c15daa4..a73e922e 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -69,7 +69,7 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance(
     }
 
     /* Due to implicit layers need to get layer list even if
-     * layerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
+     * enabledLayerNameCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
      * get layer list (both instance and device) via loader_layer_scan(). */
     memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list));
     memset(&ptr_instance->device_layer_list, 0, sizeof(ptr_instance->device_layer_list));
@@ -80,8 +80,8 @@ LOADER_EXPORT VkResult VKAPI vkCreateInstance(
                       &ptr_instance->device_layer_list);
 
     /* validate the app requested layers to be enabled */
-    if (pCreateInfo->layerCount > 0) {
-        res = loader_validate_layers(pCreateInfo->layerCount,
+    if (pCreateInfo->enabledLayerNameCount > 0) {
+        res = loader_validate_layers(pCreateInfo->enabledLayerNameCount,
                                      pCreateInfo->ppEnabledLayerNames,
                                      &ptr_instance->instance_layer_list);
         if (res != VK_SUCCESS) {
@@ -255,13 +255,13 @@ LOADER_EXPORT void VKAPI vkGetPhysicalDeviceProperties(
 
 LOADER_EXPORT void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
                                             VkPhysicalDevice gpu,
-                                            uint32_t* pCount,
+                                            uint32_t* pQueueFamilyPropertyCount,
                                             VkQueueFamilyProperties* pQueueProperties)
 {
     const VkLayerInstanceDispatchTable *disp;
 
     disp = loader_get_instance_dispatch(gpu);
-    disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pQueueProperties);
+    disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount, pQueueProperties);
 }
 
 LOADER_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties(
@@ -306,28 +306,28 @@ LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
 LOADER_EXPORT VkResult VKAPI vkEnumerateDeviceExtensionProperties(
     VkPhysicalDevice                            physicalDevice,
     const char*                                 pLayerName,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkExtensionProperties*                      pProperties)
 {
     VkResult res;
 
     loader_platform_thread_lock_mutex(&loader_lock);
     //TODO convert over to using instance chain dispatch
-    res = loader_EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
+    res = loader_EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
     loader_platform_thread_unlock_mutex(&loader_lock);
     return res;
 }
 
 LOADER_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
     VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkLayerProperties*                          pProperties)
 {
     VkResult res;
 
     loader_platform_thread_lock_mutex(&loader_lock);
     //TODO convert over to using instance chain dispatch
-    res = loader_EnumerateDeviceLayerProperties(physicalDevice, pCount, pProperties);
+    res = loader_EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
     loader_platform_thread_unlock_mutex(&loader_lock);
     return res;
 }
@@ -468,49 +468,49 @@ LOADER_EXPORT void VKAPI vkGetImageMemoryRequirements(VkDevice device, VkImage i
     disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
 }
 
-LOADER_EXPORT void VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
+LOADER_EXPORT void VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+    disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
-LOADER_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties)
+LOADER_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
 {
     const VkLayerInstanceDispatchTable *disp;
 
     disp = loader_get_instance_dispatch(physicalDevice);
 
-    disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+    disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
+    return disp->QueueBindSparseBufferMemory(queue, buffer, bindInfoCount, pBindInfo);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
+    return disp->QueueBindSparseImageOpaqueMemory(queue, image, bindInfoCount, pBindInfo);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
+    return disp->QueueBindSparseImageMemory(queue, image, bindInfoCount, pBindInfo);
 }
 
 LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
@@ -801,22 +801,22 @@ LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCa
     return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
 }
 
-LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
+LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pPipelines);
 }
 
 LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
@@ -920,13 +920,13 @@ LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDesc
     return disp->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
 }
 
-LOADER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets)
+LOADER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    return disp->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+    return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
 }
 
 LOADER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
@@ -1022,7 +1022,7 @@ LOADER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
 
     res = disp->AllocCommandBuffers(device, pAllocInfo, pCmdBuffers);
     if (res == VK_SUCCESS) {
-        for (uint32_t i =0; i < pAllocInfo->count; i++) {
+        for (uint32_t i =0; i < pAllocInfo->bufferCount; i++) {
             if (pCmdBuffers[i]) {
                 loader_init_dispatch(pCmdBuffers[i], disp);
             }
@@ -1035,14 +1035,14 @@ LOADER_EXPORT VkResult VKAPI vkAllocCommandBuffers(
 LOADER_EXPORT void VKAPI vkFreeCommandBuffers(
         VkDevice                                device,
         VkCmdPool                               cmdPool,
-        uint32_t                                count,
+        uint32_t                                commandBufferCount,
         const VkCmdBuffer*                      pCommandBuffers)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(device);
 
-    disp->FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+    disp->FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers);
 }
 
 LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
@@ -1162,13 +1162,13 @@ LOADER_EXPORT void VKAPI vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStenc
     disp->CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
 }
 
-LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
+LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
 LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
@@ -1207,22 +1207,22 @@ LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexC
     disp->CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+    disp->CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride);
 }
 
-LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
+LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(cmdBuffer);
 
-    disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+    disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride);
 }
 
 LOADER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
diff --git a/loader/wsi_swapchain.c b/loader/wsi_swapchain.c
index 5bdf284d..a20549a8 100644
--- a/loader/wsi_swapchain.c
+++ b/loader/wsi_swapchain.c
@@ -53,7 +53,7 @@ void wsi_swapchain_create_instance(
 {
     ptr_instance->wsi_swapchain_enabled = false;
 
-    for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
             ptr_instance->wsi_swapchain_enabled = true;
             return;