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

24 files changed, 377 insertions, 372 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 3a233fa3..77a9410c 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -442,11 +442,11 @@ static void demo_flush_init_cmd(struct demo *demo)
     VkSubmitInfo submit_info = {
         .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
         .pNext = NULL,
-        .waitSemCount = 0,
+        .waitSemaphoreCount = 0,
         .pWaitSemaphores = NULL,
-        .cmdBufferCount = 1,
+        .commandBufferCount = 1,
         .pCommandBuffers = cmd_bufs,
-        .signalSemCount = 0,
+        .signalSemaphoreCount = 0,
         .pSignalSemaphores = NULL
     };
 
@@ -475,7 +475,7 @@ static void demo_set_image_layout(
             .pNext = NULL,
             .cmdPool = demo->cmd_pool,
             .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-            .count = 1,
+            .bufferCount = 1,
         };
 
         err = vkAllocCommandBuffers(demo->device, &cmd, &demo->cmd);
@@ -676,11 +676,11 @@ static void demo_draw(struct demo *demo)
     VkSubmitInfo submit_info = {
         .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
         .pNext = NULL,
-        .waitSemCount = 1,
+        .waitSemaphoreCount = 1,
         .pWaitSemaphores = &presentCompleteSemaphore,
-        .cmdBufferCount = 1,
+        .commandBufferCount = 1,
         .pCommandBuffers = &demo->buffers[demo->current_buffer].cmd,
-        .signalSemCount = 0,
+        .signalSemaphoreCount = 0,
         .pSignalSemaphores = NULL
     };
 
@@ -1301,8 +1301,8 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
     const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
         .pNext = NULL,
-        .count = 2,
-        .pBinding = layout_bindings,
+        .bindingCount = 2,
+        .pBindings = layout_bindings,
     };
     VkResult U_ASSERT_ONLY err;
 
@@ -1313,7 +1313,7 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
     const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
         .sType              = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
         .pNext              = NULL,
-        .descriptorSetCount = 1,
+        .setLayoutCount = 1,
         .pSetLayouts        = &demo->desc_layout,
     };
 
@@ -1360,16 +1360,16 @@ static void demo_prepare_render_pass(struct demo *demo)
         .pNext = NULL,
         .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
         .flags = 0,
-        .inputCount = 0,
+        .inputAttachmentCount = 0,
         .pInputAttachments = NULL,
-        .colorCount = 1,
+        .colorAttachmentCount = 1,
         .pColorAttachments = &color_reference,
         .pResolveAttachments = NULL,
         .depthStencilAttachment = {
             .attachment = 1,
             .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
         },
-        .preserveCount = 0,
+        .preserveAttachmentCount = 0,
         .pPreserveAttachments = NULL,
     };
     const VkRenderPassCreateInfo rp_info = {
@@ -1666,19 +1666,19 @@ static void demo_prepare_descriptor_pool(struct demo *demo)
     const VkDescriptorTypeCount type_counts[2] = {
         [0] = {
             .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-            .count = 1,
+            .descriptorCount = 1,
         },
         [1] = {
             .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-            .count = DEMO_TEXTURE_COUNT,
+            .descriptorCount = DEMO_TEXTURE_COUNT,
         },
     };
     const VkDescriptorPoolCreateInfo descriptor_pool = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
         .pNext = NULL,
         .maxSets = 1,
-        .count = 2,
-        .pTypeCount = type_counts,
+        .typeCount = 2,
+        .pTypeCounts = type_counts,
     };
     VkResult U_ASSERT_ONLY err;
 
@@ -1698,7 +1698,7 @@ static void demo_prepare_descriptor_set(struct demo *demo)
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO,
         .pNext = NULL,
         .descriptorPool = demo->desc_pool,
-        .count = 1,
+        .setLayoutCount = 1,
         .pSetLayouts = &demo->desc_layout
     };
     err = vkAllocDescriptorSets(demo->device, &alloc_info, &demo->desc_set);
@@ -1715,14 +1715,14 @@ static void demo_prepare_descriptor_set(struct demo *demo)
 
     writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
     writes[0].destSet = demo->desc_set;
-    writes[0].count = 1;
+    writes[0].descriptorCount = 1;
     writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
     writes[0].pBufferInfo = &demo->uniform_data.buffer_info;
 
     writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
     writes[1].destSet = demo->desc_set;
     writes[1].destBinding = 1;
-    writes[1].count = DEMO_TEXTURE_COUNT;
+    writes[1].descriptorCount = DEMO_TEXTURE_COUNT;
     writes[1].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     writes[1].pImageInfo = tex_descs;
 
@@ -1775,7 +1775,7 @@ static void demo_prepare(struct demo *demo)
         .pNext = NULL,
         .cmdPool = demo->cmd_pool,
         .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-        .count = 1,
+        .bufferCount = 1,
     };
 
     demo_prepare_buffers(demo);
@@ -2269,9 +2269,9 @@ static void demo_init_vk(struct demo *demo)
         .pNext = NULL,
         .pAppInfo = &app,
         .pAllocCb = NULL,
-        .layerCount = enabled_layer_count,
+        .enabledLayerNameCount = enabled_layer_count,
         .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? instance_validation_layers : NULL),
-        .extensionCount = enabled_extension_count,
+        .enabledExtensionNameCount = enabled_extension_count,
         .ppEnabledExtensionNames = (const char *const*) extension_names,
     };
 
@@ -2428,7 +2428,7 @@ static void demo_init_vk(struct demo *demo)
         .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
         .pNext = NULL,
         .queueFamilyIndex = gfx_queue_idx,
-        .queueCount = 1,
+        .queuePriorityCount = 1,
         .pQueuePriorities = queue_priorities
     };
 
@@ -2437,9 +2437,9 @@ static void demo_init_vk(struct demo *demo)
         .pNext = NULL,
         .requestedQueueCount = 1,
         .pRequestedQueues = &queue,
-        .layerCount = enabled_layer_count,
+        .enabledLayerNameCount = enabled_layer_count,
         .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? device_validation_layers : NULL),
-        .extensionCount = enabled_extension_count,
+        .enabledExtensionNameCount = enabled_extension_count,
         .ppEnabledExtensionNames = (const char *const*) extension_names,
         .pEnabledFeatures = NULL, // If specific features are required, pass them in here
     };
diff --git a/demos/tri.c b/demos/tri.c
index dc444a13..83f99b75 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -282,11 +282,11 @@ static void demo_flush_init_cmd(struct demo *demo)
     VkSubmitInfo submit_info = {
         .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
         .pNext = NULL,
-        .waitSemCount = 0,
+        .waitSemaphoreCount = 0,
         .pWaitSemaphores = NULL,
-        .cmdBufferCount = 1,
+        .commandBufferCount = 1,
         .pCommandBuffers = cmd_bufs,
-        .signalSemCount = 0,
+        .signalSemaphoreCount = 0,
         .pSignalSemaphores = NULL
     };
 
@@ -315,7 +315,7 @@ static void demo_set_image_layout(
             .pNext = NULL,
             .cmdPool = demo->cmd_pool,
             .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-            .count = 1,
+            .bufferCount = 1,
         };
 
         err = vkAllocCommandBuffers(demo->device, &cmd, &demo->setup_cmd);
@@ -496,11 +496,11 @@ static void demo_draw(struct demo *demo)
     VkSubmitInfo submit_info = {
         .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
         .pNext = NULL,
-        .waitSemCount = 1,
+        .waitSemaphoreCount = 1,
         .pWaitSemaphores = &presentCompleteSemaphore,
-        .cmdBufferCount = 1,
+        .commandBufferCount = 1,
         .pCommandBuffers = &demo->draw_cmd,
-        .signalSemCount = 0,
+        .signalSemaphoreCount = 0,
         .pSignalSemaphores = NULL
     };
 
@@ -1030,9 +1030,9 @@ static void demo_prepare_vertices(struct demo *demo)
 
     demo->vertices.vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
     demo->vertices.vi.pNext = NULL;
-    demo->vertices.vi.bindingCount = 1;
+    demo->vertices.vi.vertexBindingDescriptionCount = 1;
     demo->vertices.vi.pVertexBindingDescriptions = demo->vertices.vi_bindings;
-    demo->vertices.vi.attributeCount = 2;
+    demo->vertices.vi.vertexAttributeDescriptionCount = 2;
     demo->vertices.vi.pVertexAttributeDescriptions = demo->vertices.vi_attrs;
 
     demo->vertices.vi_bindings[0].binding = VERTEX_BUFFER_BIND_ID;
@@ -1061,8 +1061,8 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
     const VkDescriptorSetLayoutCreateInfo descriptor_layout = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
         .pNext = NULL,
-        .count = 1,
-        .pBinding = &layout_binding,
+        .bindingCount = 1,
+        .pBindings = &layout_binding,
     };
     VkResult U_ASSERT_ONLY err;
 
@@ -1073,7 +1073,7 @@ static void demo_prepare_descriptor_layout(struct demo *demo)
     const VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {
         .sType              = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
         .pNext              = NULL,
-        .descriptorSetCount = 1,
+        .setLayoutCount = 1,
         .pSetLayouts        = &demo->desc_layout,
     };
 
@@ -1120,16 +1120,16 @@ static void demo_prepare_render_pass(struct demo *demo)
         .pNext = NULL,
         .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
         .flags = 0,
-        .inputCount = 0,
+        .inputAttachmentCount = 0,
         .pInputAttachments = NULL,
-        .colorCount = 1,
+        .colorAttachmentCount = 1,
         .pColorAttachments = &color_reference,
         .pResolveAttachments = NULL,
         .depthStencilAttachment = {
             .attachment = 1,
             .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
         },
-        .preserveCount = 0,
+        .preserveAttachmentCount = 0,
         .pPreserveAttachments = NULL,
     };
     const VkRenderPassCreateInfo rp_info = {
@@ -1415,14 +1415,14 @@ static void demo_prepare_descriptor_pool(struct demo *demo)
 {
     const VkDescriptorTypeCount type_count = {
         .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
-        .count = DEMO_TEXTURE_COUNT,
+        .descriptorCount = DEMO_TEXTURE_COUNT,
     };
     const VkDescriptorPoolCreateInfo descriptor_pool = {
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
         .pNext = NULL,
         .maxSets = 1,
-        .count = 1,
-        .pTypeCount = &type_count,
+        .typeCount = 1,
+        .pTypeCounts = &type_count,
     };
     VkResult U_ASSERT_ONLY err;
 
@@ -1442,7 +1442,7 @@ static void demo_prepare_descriptor_set(struct demo *demo)
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO,
         .pNext = NULL,
         .descriptorPool = demo->desc_pool,
-        .count = 1,
+        .setLayoutCount = 1,
         .pSetLayouts = &demo->desc_layout
     };
     err = vkAllocDescriptorSets(demo->device, &alloc_info, &demo->desc_set);
@@ -1458,7 +1458,7 @@ static void demo_prepare_descriptor_set(struct demo *demo)
     memset(&write, 0, sizeof(write));
     write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
     write.destSet = demo->desc_set;
-    write.count = DEMO_TEXTURE_COUNT;
+    write.descriptorCount = DEMO_TEXTURE_COUNT;
     write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
     write.pImageInfo = tex_descs;
 
@@ -1511,7 +1511,7 @@ static void demo_prepare(struct demo *demo)
         .pNext = NULL,
         .cmdPool = demo->cmd_pool,
         .level = VK_CMD_BUFFER_LEVEL_PRIMARY,
-        .count = 1,
+        .bufferCount = 1,
     };
     err = vkAllocCommandBuffers(demo->device, &cmd, &demo->draw_cmd);
     assert(!err);
@@ -1860,9 +1860,9 @@ static void demo_init_vk(struct demo *demo)
         .pNext = NULL,
         .pAppInfo = &app,
         .pAllocCb = &cb,
-        .layerCount = enabled_layer_count,
+        .enabledLayerNameCount = enabled_layer_count,
         .ppEnabledLayerNames = (const char *const*) layer_names,
-        .extensionCount = enabled_extension_count,
+        .enabledExtensionNameCount = enabled_extension_count,
         .ppEnabledExtensionNames = (const char *const*) extension_names,
     };
     float queue_priorities[1] = { 0.0 };
@@ -1870,7 +1870,7 @@ static void demo_init_vk(struct demo *demo)
         .sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
         .pNext = NULL,
         .queueFamilyIndex = 0,
-        .queueCount = 1,
+        .queuePriorityCount = 1,
         .pQueuePriorities = queue_priorities
     };
     uint32_t gpu_count;
@@ -1964,9 +1964,9 @@ static void demo_init_vk(struct demo *demo)
         .pNext = NULL,
         .requestedQueueCount = 1,
         .pRequestedQueues = &queue,
-        .layerCount = enabled_layer_count,
+        .enabledLayerNameCount = enabled_layer_count,
         .ppEnabledLayerNames = (const char *const*) ((demo->validate) ? device_validation_layers : NULL),
-        .extensionCount = enabled_extension_count,
+        .enabledExtensionNameCount = enabled_extension_count,
         .ppEnabledExtensionNames = (const char *const*) extension_names,
     };
 
diff --git a/demos/vulkaninfo.c b/demos/vulkaninfo.c
index c8553efe..91ded08e 100644
--- a/demos/vulkaninfo.c
+++ b/demos/vulkaninfo.c
@@ -390,9 +390,9 @@ static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu)
         .pNext = NULL,
         .requestedQueueCount = 0,
         .pRequestedQueues = NULL,
-        .layerCount = 0,
+        .enabledLayerNameCount = 0,
         .ppEnabledLayerNames = NULL,
-        .extensionCount = 0,
+        .enabledExtensionNameCount = 0,
         .ppEnabledExtensionNames = NULL,
     };
     VkResult U_ASSERT_ONLY err;
@@ -475,9 +475,9 @@ static void app_dev_init(struct app_dev *dev, struct app_gpu *gpu)
     info.requestedQueueCount = gpu->queue_count;
     info.pRequestedQueues = gpu->queue_reqs;
 
-    info.layerCount = 0;
+    info.enabledLayerNameCount = 0;
     info.ppEnabledLayerNames = NULL;
-    info.extensionCount = enabled_extension_count;
+    info.enabledExtensionNameCount = enabled_extension_count;
     info.ppEnabledExtensionNames = (const char*const*) known_extensions;
     dev->gpu = gpu;
     err = vkCreateDevice(gpu->obj, &info, &dev->obj);
@@ -533,9 +533,9 @@ static void app_create_instance(struct app_instance *inst)
         .pNext = NULL,
         .pAppInfo = &app_info,
         .pAllocCb = NULL,
-        .layerCount = 0,
+        .enabledLayerNameCount = 0,
         .ppEnabledLayerNames = NULL,
-        .extensionCount = 0,
+        .enabledExtensionNameCount = 0,
         .ppEnabledExtensionNames = NULL,
     };
     VkResult U_ASSERT_ONLY err;
@@ -610,7 +610,7 @@ static void app_create_instance(struct app_instance *inst)
         }
     }
 
-    inst_info.extensionCount = global_extension_count;
+    inst_info.enabledExtensionNameCount = global_extension_count;
     inst_info.ppEnabledExtensionNames = (const char * const *) known_extensions;
 
     err = vkCreateInstance(&inst_info, &inst->instance);
@@ -660,7 +660,7 @@ static void app_gpu_init(struct app_gpu *gpu, uint32_t id, VkPhysicalDevice obj)
         gpu->queue_reqs[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
         gpu->queue_reqs[i].pNext = NULL;
         gpu->queue_reqs[i].queueFamilyIndex = i;
-        gpu->queue_reqs[i].queueCount = gpu->queue_props[i].queueCount;
+        gpu->queue_reqs[i].queuePriorityCount = gpu->queue_props[i].queueCount;
         gpu->queue_reqs[i].pQueuePriorities = queue_priorities;
     }
 
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 5d2e62d1..b217e226 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -135,7 +135,7 @@ static VkResult dev_create_queues(struct nulldrv_dev *dev,
         const VkDeviceQueueCreateInfo *q = &queues[i];
         VkResult ret = VK_SUCCESS;
 
-        if (q->queueCount == 1 && !dev->queues[q->queueFamilyIndex]) {
+        if (q->queuePriorityCount == 1 && !dev->queues[q->queueFamilyIndex]) {
             ret = nulldrv_queue_create(dev, q->queueFamilyIndex,
                     &dev->queues[q->queueFamilyIndex]);
         }
@@ -196,7 +196,7 @@ static VkResult nulldrv_dev_create(struct nulldrv_gpu *gpu,
     if (!dev)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
-    for (i = 0; i < info->extensionCount; i++) {
+    for (i = 0; i < info->enabledExtensionNameCount; i++) {
         const enum nulldrv_ext_type ext = nulldrv_gpu_lookup_extension(
                     gpu,
                     info->ppEnabledExtensionNames[i]);
@@ -487,7 +487,7 @@ static VkResult nulldrv_cmd_create(struct nulldrv_dev *dev,
     struct nulldrv_cmd *cmd;
     uint32_t num_allocated = 0;
 
-    for (uint32_t i = 0; i < info->count; i++) {
+    for (uint32_t i = 0; i < info->bufferCount; i++) {
         cmd = (struct nulldrv_cmd *) nulldrv_base_create(dev, sizeof(*cmd),
                 VK_OBJECT_TYPE_COMMAND_BUFFER);
         if (!cmd) {
@@ -666,11 +666,11 @@ ICD_EXPORT VkResult VKAPI vkAllocCommandBuffers(
 ICD_EXPORT void VKAPI vkFreeCommandBuffers(
     VkDevice                                  device,
     VkCmdPool                                 cmdPool,
-    uint32_t                                  count,
+    uint32_t                                  commandBufferCount,
     const VkCmdBuffer*                        pCmdBuffers)
 {
     NULLDRV_LOG_FUNC;
-    for (uint32_t i = 0; i < count; i++) {
+    for (uint32_t i = 0; i < commandBufferCount; i++) {
         free(pCmdBuffers[i]);
     }
 }
@@ -1126,7 +1126,7 @@ ICD_EXPORT void VKAPI vkCmdBindDescriptorSets(
     VkPipelineBindPoint                     pipelineBindPoint,
     VkPipelineLayout                        layout,
     uint32_t                                firstSet,
-    uint32_t                                setCount,
+    uint32_t                                descriptorSetCount,
     const VkDescriptorSet*                  pDescriptorSets,
     uint32_t                                dynamicOffsetCount,
     const uint32_t*                         pDynamicOffsets)
@@ -1178,7 +1178,7 @@ ICD_EXPORT void VKAPI vkCmdDrawIndirect(
     VkCmdBuffer                              cmdBuffer,
     VkBuffer                                  buffer,
     VkDeviceSize                                offset,
-    uint32_t                                    count,
+    uint32_t                                    drawCount,
     uint32_t                                    stride)
 {
     NULLDRV_LOG_FUNC;
@@ -1188,7 +1188,7 @@ ICD_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
     VkCmdBuffer                              cmdBuffer,
     VkBuffer                                  buffer,
     VkDeviceSize                                offset,
-    uint32_t                                    count,
+    uint32_t                                    drawCount,
     uint32_t                                    stride)
 {
     NULLDRV_LOG_FUNC;
@@ -1397,11 +1397,11 @@ ICD_EXPORT void VKAPI vkGetPhysicalDeviceFormatProperties(
 
 ICD_EXPORT void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
     VkPhysicalDevice                             gpu_,
-    uint32_t*                                    pCount,
+    uint32_t*                                    pQueueFamilyPropertyCount,
     VkQueueFamilyProperties*                     pProperties)
  {
     if (pProperties == NULL) {
-        *pCount = 1;
+        *pQueueFamilyPropertyCount = 1;
         return;
     }
     pProperties->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_SPARSE_MEMMGR_BIT;
@@ -1418,7 +1418,7 @@ ICD_EXPORT void VKAPI vkGetPhysicalDeviceMemoryProperties(
 
 ICD_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
         VkPhysicalDevice                            physicalDevice,
-        uint32_t*                                   pCount,
+        uint32_t*                                   pPropertyCount,
         VkLayerProperties*                          pProperties)
 {
     // TODO: Fill in with real data
@@ -1427,26 +1427,26 @@ ICD_EXPORT VkResult VKAPI vkEnumerateDeviceLayerProperties(
 
 ICD_EXPORT VkResult VKAPI vkEnumerateInstanceExtensionProperties(
     const char*                                 pLayerName,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkExtensionProperties*                      pProperties)
 {
     uint32_t copy_size;
 
     if (pProperties == NULL) {
-        *pCount = NULLDRV_EXT_COUNT;
+        *pPropertyCount = NULLDRV_EXT_COUNT;
         return VK_SUCCESS;
     }
 
-    copy_size = *pCount < NULLDRV_EXT_COUNT ? *pCount : NULLDRV_EXT_COUNT;
+    copy_size = *pPropertyCount < NULLDRV_EXT_COUNT ? *pPropertyCount : NULLDRV_EXT_COUNT;
     memcpy(pProperties, intel_gpu_exts, copy_size * sizeof(VkExtensionProperties));
-    *pCount = copy_size;
+    *pPropertyCount = copy_size;
     if (copy_size < NULLDRV_EXT_COUNT) {
         return VK_INCOMPLETE;
     }
     return VK_SUCCESS;
 }
 ICD_EXPORT VkResult VKAPI vkEnumerateInstanceLayerProperties(
-        uint32_t*                                   pCount,
+        uint32_t*                                   pPropertyCount,
         VkLayerProperties*                          pProperties)
 {
     // TODO: Fill in with real data
@@ -1456,11 +1456,11 @@ ICD_EXPORT VkResult VKAPI vkEnumerateInstanceLayerProperties(
 VkResult VKAPI vkEnumerateDeviceExtensionProperties(
     VkPhysicalDevice                            physicalDevice,
     const char*                                 pLayerName,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkExtensionProperties*                      pProperties)
 {
 
-    *pCount = 0;
+    *pPropertyCount = 0;
 
     return VK_SUCCESS;
 }
@@ -1661,7 +1661,7 @@ ICD_EXPORT VkResult VKAPI vkBindImageMemory(
 ICD_EXPORT void VKAPI vkGetImageSparseMemoryRequirements(
     VkDevice                                    device,
     VkImage                                     image,
-    uint32_t*                                   pNumRequirements,
+    uint32_t*                                   pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements)
 {
     NULLDRV_LOG_FUNC;
@@ -1674,7 +1674,7 @@ ICD_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
     uint32_t                                    samples,
     VkImageUsageFlags                           usage,
     VkImageTiling                               tiling,
-    uint32_t*                                   pNumProperties,
+    uint32_t*                                   pPropertyCount,
     VkSparseImageFormatProperties*              pProperties)
 {
     NULLDRV_LOG_FUNC;
@@ -1683,7 +1683,7 @@ ICD_EXPORT void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
 ICD_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
     VkQueue                                     queue,
     VkBuffer                                    buffer,
-    uint32_t                                    numBindings,
+    uint32_t                                    bindInfoCount,
     const VkSparseMemoryBindInfo*               pBindInfo)
 {
     NULLDRV_LOG_FUNC;
@@ -1693,7 +1693,7 @@ ICD_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
 ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
     VkQueue                                     queue,
     VkImage                                     image,
-    uint32_t                                    numBindings,
+    uint32_t                                    bindInfoCount,
     const VkSparseMemoryBindInfo*               pBindInfo)
 {
     NULLDRV_LOG_FUNC;
@@ -1703,7 +1703,7 @@ ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
 ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
     VkQueue                                     queue,
     VkImage                                     image,
-    uint32_t                                    numBindings,
+    uint32_t                                    bindInfoCount,
     const VkSparseImageMemoryBindInfo*          pBindInfo)
 {
     NULLDRV_LOG_FUNC;
@@ -1755,7 +1755,7 @@ ICD_EXPORT VkResult VKAPI vkMergePipelineCaches(
 ICD_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(
     VkDevice                                  device,
     VkPipelineCache                           pipelineCache,
-    uint32_t                                  count,
+    uint32_t                                  createInfoCount,
     const VkGraphicsPipelineCreateInfo*    pCreateInfo,
     VkPipeline*                               pPipeline)
 {
@@ -1771,7 +1771,7 @@ ICD_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(
 ICD_EXPORT VkResult VKAPI vkCreateComputePipelines(
     VkDevice                                  device,
     VkPipelineCache                           pipelineCache,
-    uint32_t                                  count,
+    uint32_t                                  createInfoCount,
     const VkComputePipelineCreateInfo*     pCreateInfo,
     VkPipeline*                               pPipeline)
 {
@@ -2017,7 +2017,7 @@ ICD_EXPORT VkResult VKAPI vkAllocDescriptorSets(
     VkResult ret = VK_SUCCESS;
     uint32_t i;
 
-    for (i = 0; i < pAllocInfo->count; i++) {
+    for (i = 0; i < pAllocInfo->setLayoutCount; i++) {
         const struct nulldrv_desc_layout *layout =
             nulldrv_desc_layout(pAllocInfo->pSetLayouts[i]);
 
@@ -2033,7 +2033,7 @@ ICD_EXPORT VkResult VKAPI vkAllocDescriptorSets(
 ICD_EXPORT VkResult VKAPI vkFreeDescriptorSets(
     VkDevice                                    device,
     VkDescriptorPool                            descriptorPool,
-    uint32_t                                    count,
+    uint32_t                                    descriptorSetCount,
     const VkDescriptorSet*                      pDescriptorSets)
 {
     NULLDRV_LOG_FUNC;
diff --git a/include/vulkan.h b/include/vulkan.h
index 742e0862..6624b8e3 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -1055,9 +1055,9 @@ typedef struct {
     const void*                                 pNext;
     const VkApplicationInfo*                    pAppInfo;
     const VkAllocCallbacks*                     pAllocCb;
-    uint32_t                                    layerCount;
+    uint32_t                                    enabledLayerNameCount;
     const char*const*                           ppEnabledLayerNames;
-    uint32_t                                    extensionCount;
+    uint32_t                                    enabledExtensionNameCount;
     const char*const*                           ppEnabledExtensionNames;
 } VkInstanceCreateInfo;
 
@@ -1286,7 +1286,7 @@ typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
     uint32_t                                    queueFamilyIndex;
-    uint32_t                                    queueCount;
+    uint32_t                                    queuePriorityCount;
     const float*                                pQueuePriorities;
 } VkDeviceQueueCreateInfo;
 
@@ -1295,9 +1295,9 @@ typedef struct {
     const void*                                 pNext;
     uint32_t                                    requestedQueueCount;
     const VkDeviceQueueCreateInfo*              pRequestedQueues;
-    uint32_t                                    layerCount;
+    uint32_t                                    enabledLayerNameCount;
     const char*const*                           ppEnabledLayerNames;
-    uint32_t                                    extensionCount;
+    uint32_t                                    enabledExtensionNameCount;
     const char*const*                           ppEnabledExtensionNames;
     const VkPhysicalDeviceFeatures*             pEnabledFeatures;
 } VkDeviceCreateInfo;
@@ -1317,11 +1317,11 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    uint32_t                                    waitSemCount;
+    uint32_t                                    waitSemaphoreCount;
     const VkSemaphore*                          pWaitSemaphores;
-    uint32_t                                    cmdBufferCount;
+    uint32_t                                    commandBufferCount;
     const VkCmdBuffer*                          pCommandBuffers;
-    uint32_t                                    signalSemCount;
+    uint32_t                                    signalSemaphoreCount;
     const VkSemaphore*                          pSignalSemaphores;
 } VkSubmitInfo;
 
@@ -1422,7 +1422,7 @@ typedef struct {
     VkBufferUsageFlags                          usage;
     VkBufferCreateFlags                         flags;
     VkSharingMode                               sharingMode;
-    uint32_t                                    queueFamilyCount;
+    uint32_t                                    queueFamilyIndexCount;
     const uint32_t*                             pQueueFamilyIndices;
 } VkBufferCreateInfo;
 
@@ -1448,7 +1448,7 @@ typedef struct {
     VkImageUsageFlags                           usage;
     VkImageCreateFlags                          flags;
     VkSharingMode                               sharingMode;
-    uint32_t                                    queueFamilyCount;
+    uint32_t                                    queueFamilyIndexCount;
     const uint32_t*                             pQueueFamilyIndices;
     VkImageLayout                               initialLayout;
 } VkImageCreateInfo;
@@ -1547,9 +1547,9 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    uint32_t                                    bindingCount;
+    uint32_t                                    vertexBindingDescriptionCount;
     const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
-    uint32_t                                    attributeCount;
+    uint32_t                                    vertexAttributeDescriptionCount;
     const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
 } VkPipelineVertexInputStateCreateInfo;
 
@@ -1718,7 +1718,7 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    uint32_t                                    descriptorSetCount;
+    uint32_t                                    setLayoutCount;
     const VkDescriptorSetLayout*                pSetLayouts;
     uint32_t                                    pushConstantRangeCount;
     const VkPushConstantRange*                  pPushConstantRanges;
@@ -1753,13 +1753,13 @@ typedef struct {
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
-    uint32_t                                    count;
-    const VkDescriptorSetLayoutBinding*         pBinding;
+    uint32_t                                    bindingCount;
+    const VkDescriptorSetLayoutBinding*         pBindings;
 } VkDescriptorSetLayoutCreateInfo;
 
 typedef struct {
     VkDescriptorType                            type;
-    uint32_t                                    count;
+    uint32_t                                    descriptorCount;
 } VkDescriptorTypeCount;
 
 typedef struct {
@@ -1767,15 +1767,15 @@ typedef struct {
     const void*                                 pNext;
     VkDescriptorPoolCreateFlags                 flags;
     uint32_t                                    maxSets;
-    uint32_t                                    count;
-    const VkDescriptorTypeCount*                pTypeCount;
+    uint32_t                                    typeCount;
+    const VkDescriptorTypeCount*                pTypeCounts;
 } VkDescriptorPoolCreateInfo;
 
 typedef struct {
     VkStructureType                             sType;
     const void*                                 pNext;
     VkDescriptorPool                            descriptorPool;
-    uint32_t                                    count;
+    uint32_t                                    setLayoutCount;
     const VkDescriptorSetLayout*                pSetLayouts;
 } VkDescriptorSetAllocInfo;
 
@@ -1797,7 +1797,7 @@ typedef struct {
     VkDescriptorSet                             destSet;
     uint32_t                                    destBinding;
     uint32_t                                    destArrayElement;
-    uint32_t                                    count;
+    uint32_t                                    descriptorCount;
     VkDescriptorType                            descriptorType;
     const VkDescriptorImageInfo*                pImageInfo;
     const VkDescriptorBufferInfo*               pBufferInfo;
@@ -1813,7 +1813,7 @@ typedef struct {
     VkDescriptorSet                             destSet;
     uint32_t                                    destBinding;
     uint32_t                                    destArrayElement;
-    uint32_t                                    count;
+    uint32_t                                    descriptorCount;
 } VkCopyDescriptorSet;
 
 typedef struct {
@@ -1851,13 +1851,13 @@ typedef struct {
     const void*                                 pNext;
     VkPipelineBindPoint                         pipelineBindPoint;
     VkSubpassDescriptionFlags                   flags;
-    uint32_t                                    inputCount;
+    uint32_t                                    inputAttachmentCount;
     const VkAttachmentReference*                pInputAttachments;
-    uint32_t                                    colorCount;
+    uint32_t                                    colorAttachmentCount;
     const VkAttachmentReference*                pColorAttachments;
     const VkAttachmentReference*                pResolveAttachments;
     VkAttachmentReference                       depthStencilAttachment;
-    uint32_t                                    preserveCount;
+    uint32_t                                    preserveAttachmentCount;
     const VkAttachmentReference*                pPreserveAttachments;
 } VkSubpassDescription;
 
@@ -1896,7 +1896,7 @@ typedef struct {
     const void*                                 pNext;
     VkCmdPool                                   cmdPool;
     VkCmdBufferLevel                            level;
-    uint32_t                                    count;
+    uint32_t                                    bufferCount;
 } VkCmdBufferAllocInfo;
 
 typedef struct {
@@ -2054,16 +2054,16 @@ typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalD
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
-typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
 typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
 typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
 typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
 typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device);
-typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pCount, VkLayerProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
 typedef void (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
@@ -2079,11 +2079,11 @@ typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffe
 typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
 typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
 typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
-typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
-typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
-typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo);
-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo);
+typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
+typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageOpaqueMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo);
 typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
 typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence);
 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
@@ -2116,8 +2116,8 @@ typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPip
 typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache);
 typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
 typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines);
 typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline);
 typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout);
 typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout);
@@ -2129,7 +2129,7 @@ typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDe
 typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool);
 typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
 typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
-typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
+typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
 typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
 typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer);
 typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer);
@@ -2140,7 +2140,7 @@ typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPo
 typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool);
 typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
 typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
-typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
+typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers);
 typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
 typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
 typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
@@ -2154,13 +2154,13 @@ typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDe
 typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
 typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
 typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
-typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
 typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
 typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
 typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
 typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
-typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
 typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
 typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
 typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
@@ -2226,7 +2226,7 @@ void VKAPI vkGetPhysicalDeviceProperties(
 
 void VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
     VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pQueueFamilyPropertyCount,
     VkQueueFamilyProperties*                    pQueueFamilyProperties);
 
 void VKAPI vkGetPhysicalDeviceMemoryProperties(
@@ -2251,22 +2251,22 @@ void VKAPI vkDestroyDevice(
 
 VkResult VKAPI vkEnumerateInstanceExtensionProperties(
     const char*                                 pLayerName,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkExtensionProperties*                      pProperties);
 
 VkResult VKAPI vkEnumerateDeviceExtensionProperties(
     VkPhysicalDevice                            physicalDevice,
     const char*                                 pLayerName,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkExtensionProperties*                      pProperties);
 
 VkResult VKAPI vkEnumerateInstanceLayerProperties(
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkLayerProperties*                          pProperties);
 
 VkResult VKAPI vkEnumerateDeviceLayerProperties(
     VkPhysicalDevice                            physicalDevice,
-    uint32_t*                                   pCount,
+    uint32_t*                                   pPropertyCount,
     VkLayerProperties*                          pProperties);
 
 void VKAPI vkGetDeviceQueue(
@@ -2348,7 +2348,7 @@ void VKAPI vkGetImageMemoryRequirements(
 void VKAPI vkGetImageSparseMemoryRequirements(
     VkDevice                                    device,
     VkImage                                     image,
-    uint32_t*                                   pNumRequirements,
+    uint32_t*                                   pSparseMemoryRequirementCount,
     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
 
 void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
@@ -2358,25 +2358,25 @@ void VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(
     uint32_t                                    samples,
     VkImageUsageFlags                           usage,
     VkImageTiling                               tiling,
-    uint32_t*                                   pNumProperties,
+    uint32_t*                                   pPropertyCount,
     VkSparseImageFormatProperties*              pProperties);
 
 VkResult VKAPI vkQueueBindSparseBufferMemory(
     VkQueue                                     queue,
     VkBuffer                                    buffer,
-    uint32_t                                    numBindings,
+    uint32_t                                    bindInfoCount,
     const VkSparseMemoryBindInfo*               pBindInfo);
 
 VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(
     VkQueue                                     queue,
     VkImage                                     image,
-    uint32_t                                    numBindings,
+    uint32_t                                    bindInfoCount,
     const VkSparseMemoryBindInfo*               pBindInfo);
 
 VkResult VKAPI vkQueueBindSparseImageMemory(
     VkQueue                                     queue,
     VkImage                                     image,
-    uint32_t                                    numBindings,
+    uint32_t                                    bindInfoCount,
     const VkSparseImageMemoryBindInfo*          pBindInfo);
 
 VkResult VKAPI vkCreateFence(
@@ -2537,14 +2537,14 @@ VkResult VKAPI vkMergePipelineCaches(
 VkResult VKAPI vkCreateGraphicsPipelines(
     VkDevice                                    device,
     VkPipelineCache                             pipelineCache,
-    uint32_t                                    count,
+    uint32_t                                    createInfoCount,
     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
     VkPipeline*                                 pPipelines);
 
 VkResult VKAPI vkCreateComputePipelines(
     VkDevice                                    device,
     VkPipelineCache                             pipelineCache,
-    uint32_t                                    count,
+    uint32_t                                    createInfoCount,
     const VkComputePipelineCreateInfo*          pCreateInfos,
     VkPipeline*                                 pPipelines);
 
@@ -2601,7 +2601,7 @@ VkResult VKAPI vkAllocDescriptorSets(
 VkResult VKAPI vkFreeDescriptorSets(
     VkDevice                                    device,
     VkDescriptorPool                            descriptorPool,
-    uint32_t                                    count,
+    uint32_t                                    descriptorSetCount,
     const VkDescriptorSet*                      pDescriptorSets);
 
 void VKAPI vkUpdateDescriptorSets(
@@ -2656,7 +2656,7 @@ VkResult VKAPI vkAllocCommandBuffers(
 void VKAPI vkFreeCommandBuffers(
     VkDevice                                    device,
     VkCmdPool                                   cmdPool,
-    uint32_t                                    count,
+    uint32_t                                    commandBufferCount,
     const VkCmdBuffer*                          pCommandBuffers);
 
 VkResult VKAPI vkBeginCommandBuffer(
@@ -2724,7 +2724,7 @@ void VKAPI vkCmdBindDescriptorSets(
     VkPipelineBindPoint                         pipelineBindPoint,
     VkPipelineLayout                            layout,
     uint32_t                                    firstSet,
-    uint32_t                                    setCount,
+    uint32_t                                    descriptorSetCount,
     const VkDescriptorSet*                      pDescriptorSets,
     uint32_t                                    dynamicOffsetCount,
     const uint32_t*                             pDynamicOffsets);
@@ -2761,14 +2761,14 @@ void VKAPI vkCmdDrawIndirect(
     VkCmdBuffer                                 cmdBuffer,
     VkBuffer                                    buffer,
     VkDeviceSize                                offset,
-    uint32_t                                    count,
+    uint32_t                                    drawCount,
     uint32_t                                    stride);
 
 void VKAPI vkCmdDrawIndexedIndirect(
     VkCmdBuffer                                 cmdBuffer,
     VkBuffer                                    buffer,
     VkDeviceSize                                offset,
-    uint32_t                                    count,
+    uint32_t                                    drawCount,
     uint32_t                                    stride);
 
 void VKAPI vkCmdDispatch(
diff --git a/layers/apidump.h b/layers/apidump.h
index 7eba182a..fb8dcf12 100644
--- a/layers/apidump.h
+++ b/layers/apidump.h
@@ -78,7 +78,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
 
     deviceExtMap[pDisp].wsi_enabled = false;
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
             deviceExtMap[pDisp].wsi_enabled = true;
 
@@ -92,7 +92,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     PFN_vkGetInstanceProcAddr gpa = pDisp->GetInstanceProcAddr;
     pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
     instanceExtMap[pDisp].wsi_enabled = false;
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].wsi_enabled = true;
 
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index c311f5d6..1d686dd1 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -168,7 +168,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
         my_data->report_data = debug_report_create_instance(
                                    pTable,
                                    *pInstance,
-                                   pCreateInfo->extensionCount,
+                                   pCreateInfo->enabledExtensionNameCount,
                                    pCreateInfo->ppEnabledExtensionNames);
 
         init_device_limits(my_data);
@@ -349,7 +349,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     my_data->device_extensions.debug_marker_enabled = false;
 
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], DEBUG_MARKER_EXTENSION_NAME) == 0) {
             /* Found a matching extension name, mark it enabled and init dispatch table*/
             initDebugMarkerTable(device);
@@ -405,9 +405,9 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(VkPhysicalDevice gpu, const VkDevi
             if (phy_dev_data->queueFamilyProperties.size() <= requestedIndex) { // requested index is out of bounds for this physical device
                 skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL",
                     "Invalid queue create request in vkCreateDevice(). Invalid queueFamilyIndex %u requested.", requestedIndex);
-            } else if (pCreateInfo->pRequestedQueues[i].queueCount > phy_dev_data->queueFamilyProperties[requestedIndex]->queueCount) {
+            } else if (pCreateInfo->pRequestedQueues[i].queuePriorityCount > phy_dev_data->queueFamilyProperties[requestedIndex]->queueCount) {
                 skipCall |= log_msg(phy_dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PHYSICAL_DEVICE, 0, 0, DEVLIMITS_INVALID_QUEUE_CREATE_REQUEST, "DL",
-                    "Invalid queue create request in vkCreateDevice(). QueueFamilyIndex %u only has %u queues, but requested queueCount is %u.", requestedIndex, phy_dev_data->queueFamilyProperties[requestedIndex]->queueCount, pCreateInfo->pRequestedQueues[i].queueCount);
+                    "Invalid queue create request in vkCreateDevice(). QueueFamilyIndex %u only has %u queues, but requested queuePriorityCount is %u.", requestedIndex, phy_dev_data->queueFamilyProperties[requestedIndex]->queueCount, pCreateInfo->pRequestedQueues[i].queuePriorityCount);
             }
         }
     }
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index cb2c46dd..bbcc4b05 100755
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -492,13 +492,13 @@ static PIPELINE_NODE* initPipeline(layer_data* dev_data, const VkGraphicsPipelin
         memcpy((void*)&pPipeline->vertexInputCI, pCreateInfo->pVertexInputState , sizeof(VkPipelineVertexInputStateCreateInfo));
         // Copy embedded ptrs
         pVICI = pCreateInfo->pVertexInputState;
-        pPipeline->vtxBindingCount = pVICI->bindingCount;
+        pPipeline->vtxBindingCount = pVICI->vertexBindingDescriptionCount;
         if (pPipeline->vtxBindingCount) {
             pPipeline->pVertexBindingDescriptions = new VkVertexInputBindingDescription[pPipeline->vtxBindingCount];
             bufferSize = pPipeline->vtxBindingCount * sizeof(VkVertexInputBindingDescription);
             memcpy((void*)pPipeline->pVertexBindingDescriptions, pVICI->pVertexBindingDescriptions, bufferSize);
         }
-        pPipeline->vtxAttributeCount = pVICI->attributeCount;
+        pPipeline->vtxAttributeCount = pVICI->vertexAttributeDescriptionCount;
         if (pPipeline->vtxAttributeCount) {
             pPipeline->pVertexAttributeDescriptions = new VkVertexInputAttributeDescription[pPipeline->vtxAttributeCount];
             bufferSize = pPipeline->vtxAttributeCount * sizeof(VkVertexInputAttributeDescription);
@@ -600,7 +600,7 @@ static VkBool32 validatePipelineState(layer_data* my_data, const GLOBAL_CB_NODE*
             int subpassNumSamples = 0;
             uint32_t i;
 
-            for (i = 0; i < pSD->colorCount; i++) {
+            for (i = 0; i < pSD->colorAttachmentCount; i++) {
                 uint32_t samples;
 
                 if (pSD->pColorAttachments[i].attachment == VK_ATTACHMENT_UNUSED)
@@ -692,10 +692,10 @@ static uint32_t getUpdateCount(layer_data* my_data, const VkDevice device, const
     switch (pUpdateStruct->sType)
     {
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
-            return ((VkWriteDescriptorSet*)pUpdateStruct)->count;
+            return ((VkWriteDescriptorSet*)pUpdateStruct)->descriptorCount;
         case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET:
             // TODO : Need to understand this case better and make sure code is correct
-            return ((VkCopyDescriptorSet*)pUpdateStruct)->count;
+            return ((VkCopyDescriptorSet*)pUpdateStruct)->descriptorCount;
     }
 }
 // For given Layout Node and binding, return index where that binding begins
@@ -703,7 +703,7 @@ static uint32_t getBindingStartIndex(const LAYOUT_NODE* pLayout, const uint32_t
 {
     uint32_t offsetIndex = 0;
     for (uint32_t i = 0; i<binding; i++) {
-        offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
+        offsetIndex += pLayout->createInfo.pBindings[i].arraySize;
     }
     return offsetIndex;
 }
@@ -712,7 +712,7 @@ static uint32_t getBindingEndIndex(const LAYOUT_NODE* pLayout, const uint32_t bi
 {
     uint32_t offsetIndex = 0;
     for (uint32_t i = 0; i<=binding; i++) {
-        offsetIndex += pLayout->createInfo.pBinding[i].arraySize;
+        offsetIndex += pLayout->createInfo.pBindings[i].arraySize;
     }
     return offsetIndex-1;
 }
@@ -790,16 +790,16 @@ static VkBool32 shadowUpdateNode(layer_data* my_data, const VkDevice device, GEN
             case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
             case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
                 {
-                    VkDescriptorImageInfo *info = new VkDescriptorImageInfo[pWDS->count];
-                    memcpy(info, pWDS->pImageInfo, pWDS->count * sizeof(VkDescriptorImageInfo));
+                    VkDescriptorImageInfo *info = new VkDescriptorImageInfo[pWDS->descriptorCount];
+                    memcpy(info, pWDS->pImageInfo, pWDS->descriptorCount * sizeof(VkDescriptorImageInfo));
                     pWDS->pImageInfo = info;
             }
                 break;
             case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
             case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
                 {
-                    VkBufferView *info = new VkBufferView[pWDS->count];
-                    memcpy(info, pWDS->pTexelBufferView, pWDS->count * sizeof(VkBufferView));
+                    VkBufferView *info = new VkBufferView[pWDS->descriptorCount];
+                    memcpy(info, pWDS->pTexelBufferView, pWDS->descriptorCount * sizeof(VkBufferView));
                     pWDS->pTexelBufferView = info;
                 }
                 break;
@@ -808,8 +808,8 @@ static VkBool32 shadowUpdateNode(layer_data* my_data, const VkDevice device, GEN
             case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
             case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
                 {
-                    VkDescriptorBufferInfo *info = new VkDescriptorBufferInfo[pWDS->count];
-                    memcpy(info, pWDS->pBufferInfo, pWDS->count * sizeof(VkDescriptorBufferInfo));
+                    VkDescriptorBufferInfo *info = new VkDescriptorBufferInfo[pWDS->descriptorCount];
+                    memcpy(info, pWDS->pBufferInfo, pWDS->descriptorCount * sizeof(VkDescriptorBufferInfo));
                     pWDS->pBufferInfo = info;
                 }
                 break;
@@ -956,12 +956,12 @@ static VkBool32 validateUpdateContents(const layer_data* my_data, const VkWriteD
     // For given update type, verify that update contents are correct
     switch (pWDS->descriptorType) {
         case VK_DESCRIPTOR_TYPE_SAMPLER:
-            for (i=0; i<pWDS->count; ++i) {
+            for (i=0; i<pWDS->descriptorCount; ++i) {
                 skipCall |= validateSampler(my_data, &(pWDS->pImageInfo[i].sampler), immutable);
             }
             break;
         case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
-            for (i=0; i<pWDS->count; ++i) {
+            for (i=0; i<pWDS->descriptorCount; ++i) {
                 if (NULL == pLayoutBinding->pImmutableSamplers) {
                     pSampler = &(pWDS->pImageInfo[i].sampler);
                     if (immutable) {
@@ -986,13 +986,13 @@ static VkBool32 validateUpdateContents(const layer_data* my_data, const VkWriteD
         case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
         case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
         case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
-            for (i=0; i<pWDS->count; ++i) {
+            for (i=0; i<pWDS->descriptorCount; ++i) {
                 skipCall |= validateImageView(my_data, &(pWDS->pImageInfo[i].imageView), pWDS->pImageInfo[i].imageLayout);
             }
             break;
         case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
         case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
-            for (i=0; i<pWDS->count; ++i) {
+            for (i=0; i<pWDS->descriptorCount; ++i) {
                 skipCall |= validateBufferView(my_data, &(pWDS->pTexelBufferView[i]));
             }
             break;
@@ -1000,7 +1000,7 @@ static VkBool32 validateUpdateContents(const layer_data* my_data, const VkWriteD
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
         case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
         case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
-            for (i=0; i<pWDS->count; ++i) {
+            for (i=0; i<pWDS->descriptorCount; ++i) {
                 skipCall |= validateBufferInfo(my_data, &(pWDS->pBufferInfo[i]));
             }
             break;
@@ -1029,7 +1029,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t writeCou
         uint32_t binding = 0, endIndex = 0;
         binding = pWDS[i].destBinding;
         // Make sure that layout being updated has the binding being updated
-        if (pLayout->createInfo.count < binding) {
+        if (pLayout->createInfo.bindingCount < binding) {
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) ds, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                     "Descriptor Set %p does not have binding to match update binding %u for update type %s!", ds, binding, string_VkStructureType(pUpdate->sType));
         } else {
@@ -1046,7 +1046,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t writeCou
                 // Layout bindings match w/ update, now verify that update type & stageFlags are the same for entire update
                 if ((skipCall = validateUpdateConsistency(my_data, device, pLayout, pUpdate, startIndex, endIndex)) == VK_FALSE) {
                     // The update is within bounds and consistent, but need to make sure contents make sense as well
-                    if ((skipCall = validateUpdateContents(my_data, &pWDS[i], &pLayout->createInfo.pBinding[binding])) == VK_FALSE) {
+                    if ((skipCall = validateUpdateContents(my_data, &pWDS[i], &pLayout->createInfo.pBindings[binding])) == VK_FALSE) {
                         // Update is good. Save the update info
                         // Create new update struct for this set's shadow copy
                         GENERIC_HEADER* pNewNode = NULL;
@@ -1080,14 +1080,14 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t writeCou
         pSrcLayout = pSrcSet->pLayout;
         pDstLayout = pDstSet->pLayout;
         // Validate that src binding is valid for src set layout
-        if (pSrcLayout->createInfo.count < pCDS[i].srcBinding) {
+        if (pSrcLayout->createInfo.bindingCount < pCDS[i].srcBinding) {
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pSrcSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                 "Copy descriptor update %u has srcBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
-                i, pCDS[i].srcBinding, (uint64_t) pSrcLayout->layout, pSrcLayout->createInfo.count-1);
-        } else if (pDstLayout->createInfo.count < pCDS[i].destBinding) {
+                i, pCDS[i].srcBinding, (uint64_t) pSrcLayout->layout, pSrcLayout->createInfo.bindingCount-1);
+        } else if (pDstLayout->createInfo.bindingCount < pCDS[i].destBinding) {
             skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDstSet->set, 0, DRAWSTATE_INVALID_UPDATE_INDEX, "DS",
                 "Copy descriptor update %u has destBinding %u which is out of bounds for underlying SetLayout %#" PRIxLEAST64 " which only has bindings 0-%u.",
-                i, pCDS[i].destBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.count-1);
+                i, pCDS[i].destBinding, (uint64_t) pDstLayout->layout, pDstLayout->createInfo.bindingCount-1);
         } else {
             // Proceed with validation. Bindings are ok, but make sure update is within bounds of given layout
             srcEndIndex = getUpdateEndIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
@@ -1105,7 +1105,7 @@ static VkBool32 dsUpdate(layer_data* my_data, VkDevice device, uint32_t writeCou
             } else {
                 srcStartIndex = getUpdateStartIndex(my_data, device, pSrcLayout, pCDS[i].srcBinding, pCDS[i].srcArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
                 dstStartIndex = getUpdateStartIndex(my_data, device, pDstLayout, pCDS[i].destBinding, pCDS[i].destArrayElement, (const GENERIC_HEADER*)&(pCDS[i]));
-                for (uint32_t j=0; j<pCDS[i].count; ++j) {
+                for (uint32_t j=0; j<pCDS[i].descriptorCount; ++j) {
                     // For copy just make sure that the types match and then perform the update
                     if (pSrcLayout->descriptorTypes[srcStartIndex+j] != pDstLayout->descriptorTypes[dstStartIndex+j]) {
                         skipCall |= log_msg(my_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType) 0, 0, 0, DRAWSTATE_DESCRIPTOR_TYPE_MISMATCH, "DS",
@@ -1134,13 +1134,13 @@ static VkBool32 validate_descriptor_availability_in_pool(layer_data* dev_data, P
                     "Unable to find set layout node for layout %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pSetLayouts[i]);
         } else {
             uint32_t typeIndex = 0, typeCount = 0;
-            for (j=0; j<pLayout->createInfo.count; ++j) {
-                typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBinding[j].descriptorType);
-                typeCount = pLayout->createInfo.pBinding[j].arraySize;
+            for (j=0; j<pLayout->createInfo.bindingCount; ++j) {
+                typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBindings[j].descriptorType);
+                typeCount = pLayout->createInfo.pBindings[j].arraySize;
                 if (typeCount > pPoolNode->availableDescriptorTypeCount[typeIndex]) {
                     skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, (uint64_t) pLayout->layout, 0, DRAWSTATE_DESCRIPTOR_POOL_EMPTY, "DS",
                         "Unable to allocate %u descriptors of type %s from pool %#" PRIxLEAST64 ". This pool only has %u descriptors of this type remaining.",
-                            typeCount, string_VkDescriptorType(pLayout->createInfo.pBinding[j].descriptorType), (uint64_t) pPoolNode->pool, pPoolNode->availableDescriptorTypeCount[typeIndex]);
+                            typeCount, string_VkDescriptorType(pLayout->createInfo.pBindings[j].descriptorType), (uint64_t) pPoolNode->pool, pPoolNode->availableDescriptorTypeCount[typeIndex]);
                 } else { // Decrement available descriptors of this type
                     pPoolNode->availableDescriptorTypeCount[typeIndex] -= typeCount;
                 }
@@ -1237,12 +1237,12 @@ static void deleteLayouts(layer_data* my_data)
         return;
     for (auto ii=my_data->layoutMap.begin(); ii!=my_data->layoutMap.end(); ++ii) {
         LAYOUT_NODE* pLayout = (*ii).second;
-        if (pLayout->createInfo.pBinding) {
-            for (uint32_t i=0; i<pLayout->createInfo.count; i++) {
-                if (pLayout->createInfo.pBinding[i].pImmutableSamplers)
-                    delete[] pLayout->createInfo.pBinding[i].pImmutableSamplers;
+        if (pLayout->createInfo.pBindings) {
+            for (uint32_t i=0; i<pLayout->createInfo.bindingCount; i++) {
+                if (pLayout->createInfo.pBindings[i].pImmutableSamplers)
+                    delete[] pLayout->createInfo.pBindings[i].pImmutableSamplers;
             }
-            delete[] pLayout->createInfo.pBinding;
+            delete[] pLayout->createInfo.pBindings;
         }
         delete pLayout;
     }
@@ -1576,7 +1576,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
         my_data->report_data = debug_report_create_instance(
                                    pTable,
                                    *pInstance,
-                                   pCreateInfo->extensionCount,
+                                   pCreateInfo->enabledExtensionNameCount,
                                    pCreateInfo->ppEnabledExtensionNames);
 
         init_draw_state(my_data);
@@ -1616,7 +1616,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
     dev_data->device_extensions.debug_marker_enabled = false;
 
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], DEBUG_MARKER_EXTENSION_NAME) == 0) {
             /* Found a matching extension name, mark it enabled and init dispatch table*/
             initDebugMarkerTable(device);
@@ -1732,7 +1732,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t submitCount
     layer_data* dev_data = get_my_data_ptr(get_dispatch_key(queue), layer_data_map);
     for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) {
         const VkSubmitInfo *submit = &pSubmitInfo[submit_idx];
-        for (uint32_t i=0; i < submit->cmdBufferCount; i++) {
+        for (uint32_t i=0; i < submit->commandBufferCount; i++) {
             // Validate that cmd buffers have been updated
             pCB = getCBNode(dev_data, submit->pCommandBuffers[i]);
             loader_platform_thread_lock_mutex(&globalLock);
@@ -2043,15 +2043,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, cons
         }
         memset(pNewNode, 0, sizeof(LAYOUT_NODE));
         memcpy((void*)&pNewNode->createInfo, pCreateInfo, sizeof(VkDescriptorSetLayoutCreateInfo));
-        pNewNode->createInfo.pBinding = new VkDescriptorSetLayoutBinding[pCreateInfo->count];
-        memcpy((void*)pNewNode->createInfo.pBinding, pCreateInfo->pBinding, sizeof(VkDescriptorSetLayoutBinding)*pCreateInfo->count);
+        pNewNode->createInfo.pBindings = new VkDescriptorSetLayoutBinding[pCreateInfo->bindingCount];
+        memcpy((void*)pNewNode->createInfo.pBindings, pCreateInfo->pBindings, sizeof(VkDescriptorSetLayoutBinding)*pCreateInfo->bindingCount);
         uint32_t totalCount = 0;
-        for (uint32_t i=0; i<pCreateInfo->count; i++) {
-            totalCount += pCreateInfo->pBinding[i].arraySize;
-            if (pCreateInfo->pBinding[i].pImmutableSamplers) {
-                VkSampler** ppIS = (VkSampler**)&pNewNode->createInfo.pBinding[i].pImmutableSamplers;
-                *ppIS = new VkSampler[pCreateInfo->pBinding[i].arraySize];
-                memcpy(*ppIS, pCreateInfo->pBinding[i].pImmutableSamplers, pCreateInfo->pBinding[i].arraySize*sizeof(VkSampler));
+        for (uint32_t i=0; i<pCreateInfo->bindingCount; i++) {
+            totalCount += pCreateInfo->pBindings[i].arraySize;
+            if (pCreateInfo->pBindings[i].pImmutableSamplers) {
+                VkSampler** ppIS = (VkSampler**)&pNewNode->createInfo.pBindings[i].pImmutableSamplers;
+                *ppIS = new VkSampler[pCreateInfo->pBindings[i].arraySize];
+                memcpy(*ppIS, pCreateInfo->pBindings[i].pImmutableSamplers, pCreateInfo->pBindings[i].arraySize*sizeof(VkSampler));
             }
         }
         if (totalCount > 0) {
@@ -2059,10 +2059,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, cons
             pNewNode->stageFlags.resize(totalCount);
             uint32_t offset = 0;
             uint32_t j = 0;
-            for (uint32_t i=0; i<pCreateInfo->count; i++) {
-                for (j = 0; j < pCreateInfo->pBinding[i].arraySize; j++) {
-                    pNewNode->descriptorTypes[offset + j] = pCreateInfo->pBinding[i].descriptorType;
-                    pNewNode->stageFlags[offset + j] = pCreateInfo->pBinding[i].stageFlags;
+            for (uint32_t i=0; i<pCreateInfo->bindingCount; i++) {
+                for (j = 0; j < pCreateInfo->pBindings[i].arraySize; j++) {
+                    pNewNode->descriptorTypes[offset + j] = pCreateInfo->pBindings[i].descriptorType;
+                    pNewNode->stageFlags[offset + j] = pCreateInfo->pBindings[i].stageFlags;
                 }
                 offset += j;
             }
@@ -2085,9 +2085,9 @@ VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCre
     VkResult result = dev_data->device_dispatch_table->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
     if (VK_SUCCESS == result) {
         PIPELINE_LAYOUT_NODE plNode = dev_data->pipelineLayoutMap[*pPipelineLayout];
-        plNode.descriptorSetLayouts.resize(pCreateInfo->descriptorSetCount);
+        plNode.descriptorSetLayouts.resize(pCreateInfo->setLayoutCount);
         uint32_t i = 0;
-        for (i=0; i<pCreateInfo->descriptorSetCount; ++i) {
+        for (i=0; i<pCreateInfo->setLayoutCount; ++i) {
             plNode.descriptorSetLayouts[i] = pCreateInfo->pSetLayouts[i];
         }
         plNode.pushConstantRanges.resize(pCreateInfo->pushConstantRangeCount);
@@ -2143,7 +2143,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDe
         skipCall |= log_msg(dev_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DESCRIPTOR_POOL, (uint64_t) pAllocInfo->descriptorPool, 0, DRAWSTATE_INVALID_POOL, "DS",
                 "Unable to find pool node for pool %#" PRIxLEAST64 " specified in vkAllocDescriptorSets() call", (uint64_t) pAllocInfo->descriptorPool);
     } else { // Make sure pool has all the available descriptors before calling down chain
-        skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocInfo->count, pAllocInfo->pSetLayouts);
+        skipCall |= validate_descriptor_availability_in_pool(dev_data, pPoolNode, pAllocInfo->setLayoutCount, pAllocInfo->pSetLayouts);
     }
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
@@ -2151,11 +2151,11 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, const VkDe
     if (VK_SUCCESS == result) {
         POOL_NODE *pPoolNode = getPoolNode(dev_data, pAllocInfo->descriptorPool);
         if (pPoolNode) {
-            if (pAllocInfo->count == 0) {
-                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocInfo->count, 0, DRAWSTATE_NONE, "DS",
+            if (pAllocInfo->setLayoutCount == 0) {
+                log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, pAllocInfo->setLayoutCount, 0, DRAWSTATE_NONE, "DS",
                         "AllocDescriptorSets called with 0 count");
             }
-            for (uint32_t i = 0; i < pAllocInfo->count; i++) {
+            for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
                 log_msg(dev_data->report_data, VK_DBG_REPORT_INFO_BIT, VK_OBJECT_TYPE_DESCRIPTOR_SET, (uint64_t) pDescriptorSets[i], 0, DRAWSTATE_NONE, "DS",
                         "Created Descriptor Set %#" PRIxLEAST64, (uint64_t) pDescriptorSets[i]);
                 // Create new set node and add to head of pool nodes
@@ -2214,9 +2214,9 @@ VK_LAYER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescripto
             SET_NODE* pSet = dev_data->setMap[pDescriptorSets[i]]; // getSetNode() without locking
             LAYOUT_NODE* pLayout = pSet->pLayout;
             uint32_t typeIndex = 0, typeCount = 0;
-            for (uint32_t j=0; j<pLayout->createInfo.count; ++j) {
-                typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBinding[j].descriptorType);
-                typeCount = pLayout->createInfo.pBinding[j].arraySize;
+            for (uint32_t j=0; j<pLayout->createInfo.bindingCount; ++j) {
+                typeIndex = static_cast<uint32_t>(pLayout->createInfo.pBindings[j].descriptorType);
+                typeCount = pLayout->createInfo.pBindings[j].arraySize;
                 pPoolNode->availableDescriptorTypeCount[typeIndex] += typeCount;
             }
         }
@@ -3017,7 +3017,7 @@ VK_LAYER_EXPORT void VKAPI vkCmdClearAttachments(
             const VkClearAttachment *attachment = &pAttachments[attachment_idx];
             if (attachment->aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) {
                 VkBool32 found = VK_FALSE;
-                for (uint32_t i = 0; i < pSD->colorCount; i++) {
+                for (uint32_t i = 0; i < pSD->colorAttachmentCount; i++) {
                     if (attachment->colorAttachment == pSD->pColorAttachments[i].attachment) {
                         found = VK_TRUE;
                         break;
@@ -3344,7 +3344,7 @@ bool CheckPreserved(const layer_data* my_data, VkDevice device, const VkRenderPa
     const DAGNode& node = subpass_to_node[index];
     // If this node writes to the attachment return true as next nodes need to preserve the attachment.
     const VkSubpassDescription& subpass = pCreateInfo->pSubpasses[index];
-    for (uint32_t j = 0; j < subpass.colorCount; ++j) {
+    for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
         if (attachment == subpass.pColorAttachments[j].attachment)
             return true;
     }
@@ -3361,7 +3361,7 @@ bool CheckPreserved(const layer_data* my_data, VkDevice device, const VkRenderPa
     if (result && depth > 0) {
         const VkSubpassDescription& subpass = pCreateInfo->pSubpasses[index];
         bool has_preserved = false;
-        for (uint32_t j = 0; j < subpass.preserveCount; ++j) {
+        for (uint32_t j = 0; j < subpass.preserveAttachmentCount; ++j) {
             if (subpass.pPreserveAttachments[j].attachment == attachment) {
                 has_preserved = true;
                 break;
@@ -3397,10 +3397,10 @@ bool validateDependencies(const layer_data* my_data, VkDevice device, const VkRe
     // Find for each attachment the subpasses that use them.
     for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
         const VkSubpassDescription& subpass = pCreateInfo->pSubpasses[i];
-        for (uint32_t j = 0; j < subpass.inputCount; ++j) {
+        for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
             input_attachment_to_subpass[subpass.pInputAttachments[j].attachment].push_back(i);
         }
-        for (uint32_t j = 0; j < subpass.colorCount; ++j) {
+        for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
             output_attachment_to_subpass[subpass.pColorAttachments[j].attachment].push_back(i);
         }
         if (subpass.depthStencilAttachment.attachment != VK_ATTACHMENT_UNUSED) {
@@ -3411,12 +3411,12 @@ bool validateDependencies(const layer_data* my_data, VkDevice device, const VkRe
     for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
         const VkSubpassDescription& subpass = pCreateInfo->pSubpasses[i];
         // If the attachment is an input then all subpasses that output must have a dependency relationship
-        for (uint32_t j = 0; j < subpass.inputCount; ++j) {
+        for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
             const uint32_t& attachment = subpass.pInputAttachments[j].attachment;
             CheckDependencyExists(my_data, device, i, output_attachment_to_subpass[attachment], subpass_to_node, skip_call);
         }
         // If the attachment is an output then all subpasses that use the attachment must have a dependency relationship
-        for (uint32_t j = 0; j < subpass.colorCount; ++j) {
+        for (uint32_t j = 0; j < subpass.colorAttachmentCount; ++j) {
             const uint32_t& attachment = subpass.pColorAttachments[j].attachment;
             CheckDependencyExists(my_data, device, i, output_attachment_to_subpass[attachment], subpass_to_node, skip_call);
             CheckDependencyExists(my_data, device, i, input_attachment_to_subpass[attachment], subpass_to_node, skip_call);
@@ -3430,7 +3430,7 @@ bool validateDependencies(const layer_data* my_data, VkDevice device, const VkRe
     // Loop through implicit dependencies, if this pass reads make sure the attachment is preserved for all passes after it was written.
     for (uint32_t i = 0; i < pCreateInfo->subpassCount; ++i) {
         const VkSubpassDescription& subpass = pCreateInfo->pSubpasses[i];
-        for (uint32_t j = 0; j < subpass.inputCount; ++j) {
+        for (uint32_t j = 0; j < subpass.inputAttachmentCount; ++j) {
             CheckPreserved(my_data, device, pCreateInfo, i, subpass.pInputAttachments[j].attachment, subpass_to_node, 0, skip_call);
         }
     }
@@ -3457,30 +3457,30 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRende
 
             for (uint32_t i = 0; i < localRPCI->subpassCount; i++) {
                 VkSubpassDescription *subpass = (VkSubpassDescription *) &localRPCI->pSubpasses[i];
-                const uint32_t attachmentCount = subpass->inputCount +
-                    subpass->colorCount * (1 + (subpass->pResolveAttachments?1:0)) +
-                    subpass->preserveCount;
+                const uint32_t attachmentCount = subpass->inputAttachmentCount +
+                    subpass->colorAttachmentCount * (1 + (subpass->pResolveAttachments?1:0)) +
+                    subpass->preserveAttachmentCount;
                 VkAttachmentReference *attachments = new VkAttachmentReference[attachmentCount];
 
                 memcpy(attachments, subpass->pInputAttachments,
-                        sizeof(attachments[0]) * subpass->inputCount);
+                        sizeof(attachments[0]) * subpass->inputAttachmentCount);
                 subpass->pInputAttachments = attachments;
-                attachments += subpass->inputCount;
+                attachments += subpass->inputAttachmentCount;
 
                 memcpy(attachments, subpass->pColorAttachments,
-                        sizeof(attachments[0]) * subpass->colorCount);
+                        sizeof(attachments[0]) * subpass->colorAttachmentCount);
                 subpass->pColorAttachments = attachments;
-                attachments += subpass->colorCount;
+                attachments += subpass->colorAttachmentCount;
 
                 if (subpass->pResolveAttachments) {
                     memcpy(attachments, subpass->pResolveAttachments,
-                            sizeof(attachments[0]) * subpass->colorCount);
+                            sizeof(attachments[0]) * subpass->colorAttachmentCount);
                     subpass->pResolveAttachments = attachments;
-                    attachments += subpass->colorCount;
+                    attachments += subpass->colorAttachmentCount;
                 }
 
                 memcpy(attachments, subpass->pPreserveAttachments,
-                        sizeof(attachments[0]) * subpass->preserveCount);
+                        sizeof(attachments[0]) * subpass->preserveAttachmentCount);
                 subpass->pPreserveAttachments = attachments;
             }
         }
diff --git a/layers/draw_state.h b/layers/draw_state.h
index 053dafe0..20a1b2f9 100755
--- a/layers/draw_state.h
+++ b/layers/draw_state.h
@@ -179,15 +179,15 @@ typedef struct _POOL_NODE {
     pool(pool), createInfo(*pCreateInfo), maxSets(pCreateInfo->maxSets), pSets(NULL),
     maxDescriptorTypeCount(VK_DESCRIPTOR_TYPE_END_RANGE), availableDescriptorTypeCount(VK_DESCRIPTOR_TYPE_END_RANGE)
     {
-        if (createInfo.count) { // Shadow type struct from ptr into local struct
-            size_t typeCountSize = createInfo.count * sizeof(VkDescriptorTypeCount);
-            createInfo.pTypeCount = new VkDescriptorTypeCount[typeCountSize];
-            memcpy((void*)createInfo.pTypeCount, pCreateInfo->pTypeCount, typeCountSize);
+        if (createInfo.typeCount) { // Shadow type struct from ptr into local struct
+            size_t typeCountSize = createInfo.typeCount * sizeof(VkDescriptorTypeCount);
+            createInfo.pTypeCounts = new VkDescriptorTypeCount[typeCountSize];
+            memcpy((void*)createInfo.pTypeCounts, pCreateInfo->pTypeCounts, typeCountSize);
             // Now set max counts for each descriptor type based on count of that type times maxSets
             int32_t i=0;
-            for (i=0; i<createInfo.count; ++i) {
-                uint32_t typeIndex = static_cast<uint32_t>(createInfo.pTypeCount[i].type);
-                uint32_t typeCount = createInfo.pTypeCount[i].count;
+            for (i=0; i<createInfo.typeCount; ++i) {
+                uint32_t typeIndex = static_cast<uint32_t>(createInfo.pTypeCounts[i].type);
+                uint32_t typeCount = createInfo.pTypeCounts[i].descriptorCount;
                 maxDescriptorTypeCount[typeIndex] += typeCount;
             }
             for (i=0; i<maxDescriptorTypeCount.size(); ++i) {
@@ -196,12 +196,12 @@ typedef struct _POOL_NODE {
                 availableDescriptorTypeCount[i] = maxDescriptorTypeCount[i];
             }
         } else {
-            createInfo.pTypeCount = NULL; // Make sure this is NULL so we don't try to clean it up
+            createInfo.pTypeCounts = NULL; // Make sure this is NULL so we don't try to clean it up
         }
     }
     ~_POOL_NODE() {
-        if (createInfo.pTypeCount) {
-            delete[] createInfo.pTypeCount;
+        if (createInfo.pTypeCounts) {
+            delete[] createInfo.pTypeCounts;
         }
         // TODO : pSets are currently freed in deletePools function which uses freeShadowUpdateTree function
         //  need to migrate that struct to smart ptrs for auto-cleanup
diff --git a/layers/generic.h b/layers/generic.h
index 69a8970f..c1e56215 100644
--- a/layers/generic.h
+++ b/layers/generic.h
@@ -86,7 +86,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
 
     deviceExtMap[pDisp].wsi_enabled = false;
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
             deviceExtMap[pDisp].wsi_enabled = true;
 
@@ -100,7 +100,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     PFN_vkGetInstanceProcAddr gpa = pDisp->GetInstanceProcAddr;
     pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
     instanceExtMap[pDisp].wsi_enabled = false;
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].wsi_enabled = true;
 
diff --git a/layers/image.cpp b/layers/image.cpp
index a484d645..8ae7a12f 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -119,7 +119,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
     VkResult result = pTable->CreateInstance(pCreateInfo, pInstance);
 
     if (result == VK_SUCCESS) {
-        my_data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->extensionCount,
+        my_data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->enabledExtensionNameCount,
             pCreateInfo->ppEnabledExtensionNames);
 
         InitImage(my_data);
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 7412021b..cd606271 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -962,7 +962,7 @@ VkResult VKAPI vkCreateInstance(
         my_data->report_data = debug_report_create_instance(
                                    pTable,
                                    *pInstance,
-                                   pCreateInfo->extensionCount,
+                                   pCreateInfo->enabledExtensionNameCount,
                                    pCreateInfo->ppEnabledExtensionNames);
 
         init_mem_tracker(my_data);
@@ -984,7 +984,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR");
     pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
     my_device_data->wsi_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_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
             my_device_data->wsi_enabled = true;
     }
@@ -1137,14 +1137,14 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
     printCBList(my_data, queue);
     for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) {
         const VkSubmitInfo *submit = &pSubmitInfo[submit_idx];
-        for (uint32_t i = 0; i < submit->cmdBufferCount; i++) {
+        for (uint32_t i = 0; i < submit->commandBufferCount; i++) {
             pCBInfo = get_cmd_buf_info(my_data, submit->pCommandBuffers[i]);
             pCBInfo->fenceId = fenceId;
             pCBInfo->lastSubmittedFence = fence;
             pCBInfo->lastSubmittedQueue = queue;
         }
 
-        for (uint32_t i = 0; i < submit->waitSemCount; i++) {
+        for (uint32_t i = 0; i < submit->waitSemaphoreCount; i++) {
             VkSemaphore sem = submit->pWaitSemaphores[i];
 
             if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) {
@@ -1156,7 +1156,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
                 my_data->semaphoreMap[sem] = MEMTRACK_SEMAPHORE_STATE_WAIT;
             }
         }
-        for (uint32_t i = 0; i < submit->signalSemCount; i++) {
+        for (uint32_t i = 0; i < submit->signalSemaphoreCount; i++) {
             VkSemaphore sem = submit->pWaitSemaphores[i];
 
             if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) {
@@ -1179,7 +1179,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(
     loader_platform_thread_lock_mutex(&globalLock);
     for (uint32_t submit_idx = 0; submit_idx < submitCount; submit_idx++) {
         const VkSubmitInfo *submit = &pSubmitInfo[submit_idx];
-        for (uint32_t i = 0; i < submit->waitSemCount; i++) {
+        for (uint32_t i = 0; i < submit->waitSemaphoreCount; i++) {
             VkSemaphore sem = submit->pWaitSemaphores[i];
 
             if (my_data->semaphoreMap.find(sem) != my_data->semaphoreMap.end()) {
diff --git a/layers/object_track.h b/layers/object_track.h
index ea75743c..6969b6fb 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -194,7 +194,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR");
     pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
     my_device_data->wsi_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_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
             my_device_data->wsi_enabled = true;
 
@@ -210,7 +210,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     PFN_vkGetInstanceProcAddr gpa = pDisp->GetInstanceProcAddr;
     pDisp->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(instance, "vkGetPhysicalDeviceSurfaceSupportKHR");
     instanceExtMap[pDisp].wsi_enabled = false;
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
             instanceExtMap[pDisp].wsi_enabled = true;
 
@@ -645,7 +645,7 @@ explicit_CreateInstance(
         my_data->report_data = debug_report_create_instance(
                                    pInstanceTable,
                                    *pInstance,
-                                   pCreateInfo->extensionCount,
+                                   pCreateInfo->enabledExtensionNameCount,
                                    pCreateInfo->ppEnabledExtensionNames);
         createInstanceRegisterExtensions(pCreateInfo, *pInstance);
 
@@ -826,7 +826,7 @@ explicit_AllocDescriptorSets(
     loader_platform_thread_lock_mutex(&objLock);
     skipCall |= validate_object(device, device);
     skipCall |= validate_object(device, pAllocInfo->descriptorPool);
-    for (uint32_t i = 0; i < pAllocInfo->count; i++) {
+    for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
         skipCall |= validate_object(device, pAllocInfo->pSetLayouts[i]);
     }
     loader_platform_thread_unlock_mutex(&objLock);
@@ -837,7 +837,7 @@ explicit_AllocDescriptorSets(
         device, pAllocInfo, pDescriptorSets);
 
     loader_platform_thread_lock_mutex(&objLock);
-    for (uint32_t i = 0; i < pAllocInfo->count; i++) {
+    for (uint32_t i = 0; i < pAllocInfo->setLayoutCount; i++) {
         create_obj(device, pDescriptorSets[i], VK_OBJECT_TYPE_DESCRIPTOR_SET);
     }
     loader_platform_thread_unlock_mutex(&objLock);
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 645df9c2..359a8c2e 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -1829,7 +1829,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(
 
     if (result == VK_SUCCESS) {
         layer_data *data = get_my_data_ptr(get_dispatch_key(*pInstance), layer_data_map);
-        data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->extensionCount,
+        data->report_data = debug_report_create_instance(pTable, *pInstance, pCreateInfo->enabledExtensionNameCount,
             pCreateInfo->ppEnabledExtensionNames);
 
         InitParamChecker(data);
@@ -2167,7 +2167,7 @@ bool PreQueueSubmit(
 
 bool PostQueueSubmit(
     VkQueue queue,
-    uint32_t cmdBufferCount,
+    uint32_t commandBufferCount,
     VkFence fence,
     VkResult result)
 {
@@ -4435,16 +4435,16 @@ bool PreCreateDescriptorSetLayout(
         "vkCreateDescriptorSetLayout parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfo->pBinding != nullptr)
+    if(pCreateInfo->pBindings != nullptr)
     {
-    if(pCreateInfo->pBinding->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
-        pCreateInfo->pBinding->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
+    if(pCreateInfo->pBindings->descriptorType < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
+        pCreateInfo->pBindings->descriptorType > VK_DESCRIPTOR_TYPE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCreateDescriptorSetLayout parameter, VkDescriptorType pCreateInfo->pBinding->descriptorType, is an unrecognized enumerator");
         return false;
     }
-    if(pCreateInfo->pBinding->pImmutableSamplers != nullptr)
+    if(pCreateInfo->pBindings->pImmutableSamplers != nullptr)
     {
     }
     }
@@ -4499,10 +4499,10 @@ bool PreCreateDescriptorPool(
         "vkCreateDescriptorPool parameter, VkStructureType pCreateInfo->sType, is an invalid enumerator");
         return false;
     }
-    if(pCreateInfo->pTypeCount != nullptr)
+    if(pCreateInfo->pTypeCounts != nullptr)
     {
-    if(pCreateInfo->pTypeCount->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
-        pCreateInfo->pTypeCount->type > VK_DESCRIPTOR_TYPE_END_RANGE)
+    if(pCreateInfo->pTypeCounts->type < VK_DESCRIPTOR_TYPE_BEGIN_RANGE ||
+        pCreateInfo->pTypeCounts->type > VK_DESCRIPTOR_TYPE_END_RANGE)
     {
         log_msg(mdd(device), VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, 1, "PARAMCHECK",
         "vkCreateDescriptorPool parameter, VkDescriptorType pCreateInfo->pTypeCount->type, is an unrecognized enumerator");
@@ -4623,7 +4623,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkAllocDescriptorSets(
 
     VkResult result = get_dispatch_table(pc_device_table_map, device)->AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
 
-    PostAllocDescriptorSets(device, pAllocInfo->descriptorPool, pAllocInfo->count, pDescriptorSets, result);
+    PostAllocDescriptorSets(device, pAllocInfo->descriptorPool, pAllocInfo->setLayoutCount, pDescriptorSets, result);
 
     return result;
 }
diff --git a/layers/screenshot.cpp b/layers/screenshot.cpp
index 46c015e3..eae5867b 100644
--- a/layers/screenshot.cpp
+++ b/layers/screenshot.cpp
@@ -248,11 +248,11 @@ static void writePPM( const char *filename, VkImage image1)
     VkSubmitInfo submit_info;
     submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submit_info.pNext = NULL;
-    submit_info.waitSemCount = 0;
+    submit_info.waitSemaphoreCount = 0;
     submit_info.pWaitSemaphores = NULL;
-    submit_info.cmdBufferCount = 1;
+    submit_info.commandBufferCount = 1;
     submit_info.pCommandBuffers = &cmdBuffer;
-    submit_info.signalSemCount = 0;
+    submit_info.signalSemaphoreCount = 0;
     submit_info.pSignalSemaphores = NULL;
 
     err = pTableQueue->QueueSubmit(queue, 1, &submit_info, nullFence);
@@ -327,7 +327,7 @@ static void createDeviceRegisterExtensions(const VkDeviceCreateInfo* pCreateInfo
     pDisp->AcquireNextImageKHR = (PFN_vkAcquireNextImageKHR) gpa(device, "vkAcquireNextImageKHR");
     pDisp->QueuePresentKHR = (PFN_vkQueuePresentKHR) gpa(device, "vkQueuePresentKHR");
     deviceExtMap[pDisp].wsi_enabled = false;
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0)
             deviceExtMap[pDisp].wsi_enabled = true;
     }
diff --git a/layers/shader_checker.cpp b/layers/shader_checker.cpp
index 37bcc682..53efcad7 100644
--- a/layers/shader_checker.cpp
+++ b/layers/shader_checker.cpp
@@ -111,8 +111,8 @@ struct render_pass {
             std::vector<VkFormat> color_formats;
             uint32_t j;
 
-            color_formats.reserve(subpass->colorCount);
-            for (j = 0; j < subpass->colorCount; j++) {
+            color_formats.reserve(subpass->colorAttachmentCount);
+            for (j = 0; j < subpass->colorAttachmentCount; j++) {
                 const uint32_t att = subpass->pColorAttachments[j].attachment;
                 const VkFormat format = pCreateInfo->pAttachments[att].format;
 
@@ -148,7 +148,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(
         loader_platform_thread_lock_mutex(&globalLock);
         auto& bindings = my_data->descriptor_set_layout_map[*pSetLayout];
         bindings = new std::vector<VkDescriptorSetLayoutBinding>(
-                pCreateInfo->pBinding, pCreateInfo->pBinding + pCreateInfo->count);
+                pCreateInfo->pBindings, pCreateInfo->pBindings + pCreateInfo->bindingCount);
         loader_platform_thread_unlock_mutex(&globalLock);
     }
 
@@ -167,8 +167,8 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreatePipelineLayout(
         loader_platform_thread_lock_mutex(&globalLock);
         auto& layouts = my_data->pipeline_layout_map[*pPipelineLayout];
         layouts = new std::vector<std::vector<VkDescriptorSetLayoutBinding>*>();
-        layouts->reserve(pCreateInfo->descriptorSetCount);
-        for (unsigned i = 0; i < pCreateInfo->descriptorSetCount; i++) {
+        layouts->reserve(pCreateInfo->setLayoutCount);
+        for (unsigned i = 0; i < pCreateInfo->setLayoutCount; i++) {
             layouts->push_back(my_data->descriptor_set_layout_map[pCreateInfo->pSetLayouts[i]]);
         }
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -810,7 +810,7 @@ validate_vi_consistency(layer_data *my_data, VkDevice dev, VkPipelineVertexInput
     std::unordered_map<uint32_t, VkVertexInputBindingDescription const *> bindings;
     bool pass = true;
 
-    for (unsigned i = 0; i < vi->bindingCount; i++) {
+    for (unsigned i = 0; i < vi->vertexBindingDescriptionCount; i++) {
         auto desc = &vi->pVertexBindingDescriptions[i];
         auto & binding = bindings[desc->binding];
         if (binding) {
@@ -843,7 +843,7 @@ validate_vi_against_vs_inputs(layer_data *my_data, VkDevice dev, VkPipelineVerte
     /* Build index by location */
     std::map<uint32_t, VkVertexInputAttributeDescription const *> attribs;
     if (vi) {
-        for (unsigned i = 0; i < vi->attributeCount; i++)
+        for (unsigned i = 0; i < vi->vertexAttributeDescriptionCount; i++)
             attribs[vi->pVertexAttributeDescriptions[i].location] = &vi->pVertexAttributeDescriptions[i];
     }
 
@@ -1184,7 +1184,7 @@ VkResult VKAPI vkCreateInstance(
         my_data->report_data = debug_report_create_instance(
                                    pTable,
                                    *pInstance,
-                                   pCreateInfo->extensionCount,
+                                   pCreateInfo->enabledExtensionNameCount,
                                    pCreateInfo->ppEnabledExtensionNames);
 
         init_shader_checker(my_data);
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 46c8aad3..42cf7a83 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -77,7 +77,7 @@ static void createDeviceRegisterExtensions(VkPhysicalDevice physicalDevice, cons
     // Record whether the WSI device extension was enabled for this VkDevice.
     // No need to check if the extension was advertised by
     // vkEnumerateDeviceExtensionProperties(), since the loader handles that.
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME) == 0) {
 
             my_data->deviceMap[device].deviceSwapchainExtensionEnabled = true;
@@ -101,7 +101,7 @@ static void createInstanceRegisterExtensions(const VkInstanceCreateInfo* pCreate
     // Record whether the WSI instance extension was enabled for this
     // VkInstance.  No need to check if the extension was advertised by
     // vkEnumerateInstanceExtensionProperties(), since the loader handles that.
-    for (i = 0; i < pCreateInfo->extensionCount; i++) {
+    for (i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
         if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
 
             my_data->instanceMap[instance].swapchainExtensionEnabled = true;
@@ -209,7 +209,7 @@ VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCre
         my_data->report_data = debug_report_create_instance(
                                    pTable,
                                    *pInstance,
-                                   pCreateInfo->extensionCount,
+                                   pCreateInfo->enabledExtensionNameCount,
                                    pCreateInfo->ppEnabledExtensionNames);
         // Call the following function after my_data is initialized:
         createInstanceRegisterExtensions(pCreateInfo, *pInstance);
@@ -793,7 +793,7 @@ static VkBool32 validateCreateSwapchainKHR(VkDevice device, const VkSwapchainCre
 
     // TODO: Validate the following values:
     // - pCreateInfo->sharingMode
-    // - pCreateInfo->queueFamilyCount
+    // - pCreateInfo->queueFamilyIndexCount
     // - pCreateInfo->pQueueFamilyIndices
     // - pCreateInfo->oldSwapchain
 
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;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index afcf4be0..4cef7440 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -721,7 +721,7 @@ class GenericLayerSubcommand(Subcommand):
                          '        my_data->report_data = debug_report_create_instance(\n'
                          '                                   instance_dispatch_table(*pInstance),\n'
                          '                                   *pInstance,\n'
-                         '                                   pCreateInfo->extensionCount,\n'
+                         '                                   pCreateInfo->enabledExtensionNameCount,\n'
                          '                                   pCreateInfo->ppEnabledExtensionNames);\n'
                          '        initGeneric(my_data);\n'
                          '        sprintf(str, "Completed Generic layered %s\\n");\n'
@@ -1577,7 +1577,7 @@ class ObjectTrackerSubcommand(Subcommand):
             if 'FreeCommandBuffers' in proto.name:
                 funcs.append('%s\n' % self.lineinfo.get())
                 destroy_line =  '    loader_platform_thread_lock_mutex(&objLock);\n'
-                destroy_line += '    for (uint32_t i = 0; i < count; i++) {\n'
+                destroy_line += '    for (uint32_t i = 0; i < commandBufferCount; i++) {\n'
                 destroy_line += '        destroy_obj(%s[i], %s[i]);\n' % (proto.params[-1].name, proto.params[-1].name)
                 destroy_line += '    }\n'
                 destroy_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
@@ -1911,7 +1911,7 @@ class ThreadingSubcommand(Subcommand):
                          '        my_data->report_data = debug_report_create_instance(\n'
                          '                                   pInstanceTable,\n'
                          '                                   *pInstance,\n'
-                         '                                   pCreateInfo->extensionCount,\n'
+                         '                                   pCreateInfo->enabledExtensionNameCount,\n'
                          '                                   pCreateInfo->ppEnabledExtensionNames);\n'
                          '        initThreading(my_data);\n'
                          '    }\n'
diff --git a/vk_helper.py b/vk_helper.py
index d0a5db3d..2e3a9949 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -252,6 +252,11 @@ class HeaderFileParser:
             if 'const' in full_type and '*' in full_type:
                 if name.endswith('s') or self.last_struct_count_name.lower().replace('count', '') in name.lower():
                     return True
+
+                # VkWriteDescriptorSet
+                if self.last_struct_count_name == "descriptorCount":
+                    return True
+
         return False
 
     # populate struct dicts based on struct lines
diff --git a/vulkan.py b/vulkan.py
index a74a615a..a57d1993 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -247,7 +247,7 @@ core = Extension(
 
         Proto("void", "GetPhysicalDeviceQueueFamilyProperties",
             [Param("VkPhysicalDevice", "physicalDevice"),
-             Param("uint32_t*", "pCount"),
+             Param("uint32_t*", "pQueueFamilyPropertyCount"),
              Param("VkQueueFamilyProperties*", "pQueueFamilyProperties")]),
 
         Proto("void", "GetPhysicalDeviceMemoryProperties",
@@ -272,22 +272,22 @@ core = Extension(
 
         Proto("VkResult", "EnumerateInstanceExtensionProperties",
             [Param("const char*", "pLayerName"),
-             Param("uint32_t*", "pCount"),
+             Param("uint32_t*", "pPropertyCount"),
              Param("VkExtensionProperties*", "pProperties")]),
 
         Proto("VkResult", "EnumerateDeviceExtensionProperties",
             [Param("VkPhysicalDevice", "physicalDevice"),
              Param("const char*", "pLayerName"),
-             Param("uint32_t*", "pCount"),
+             Param("uint32_t*", "pPropertyCount"),
              Param("VkExtensionProperties*", "pProperties")]),
 
         Proto("VkResult", "EnumerateInstanceLayerProperties",
-            [Param("uint32_t*", "pCount"),
+            [Param("uint32_t*", "pPropertyCount"),
              Param("VkLayerProperties*", "pProperties")]),
 
         Proto("VkResult", "EnumerateDeviceLayerProperties",
             [Param("VkPhysicalDevice", "physicalDevice"),
-             Param("uint32_t*", "pCount"),
+             Param("uint32_t*", "pPropertyCount"),
              Param("VkLayerProperties*", "pProperties")]),
 
         Proto("void", "GetDeviceQueue",
@@ -369,7 +369,7 @@ core = Extension(
         Proto("void", "GetImageSparseMemoryRequirements",
             [Param("VkDevice", "device"),
              Param("VkImage", "image"),
-             Param("uint32_t*", "pNumRequirements"),
+             Param("uint32_t*", "pSparseMemoryRequirementCount"),
              Param("VkSparseImageMemoryRequirements*", "pSparseMemoryRequirements")]),
 
         Proto("void", "GetPhysicalDeviceSparseImageFormatProperties",
@@ -379,25 +379,25 @@ core = Extension(
              Param("uint32_t", "samples"),
              Param("VkImageUsageFlags", "usage"),
              Param("VkImageTiling", "tiling"),
-             Param("uint32_t*", "pNumProperties"),
+             Param("uint32_t*", "pPropertyCount"),
              Param("VkSparseImageFormatProperties*", "pProperties")]),
 
         Proto("VkResult", "QueueBindSparseBufferMemory",
             [Param("VkQueue", "queue"),
              Param("VkBuffer", "buffer"),
-             Param("uint32_t", "numBindings"),
+             Param("uint32_t", "bindInfoCount"),
              Param("const VkSparseMemoryBindInfo*", "pBindInfo")]),
 
         Proto("VkResult", "QueueBindSparseImageOpaqueMemory",
             [Param("VkQueue", "queue"),
              Param("VkImage", "image"),
-             Param("uint32_t", "numBindings"),
+             Param("uint32_t", "bindInfoCount"),
              Param("const VkSparseMemoryBindInfo*", "pBindInfo")]),
 
         Proto("VkResult", "QueueBindSparseImageMemory",
             [Param("VkQueue", "queue"),
              Param("VkImage", "image"),
-             Param("uint32_t", "numBindings"),
+             Param("uint32_t", "bindInfoCount"),
              Param("const VkSparseImageMemoryBindInfo*", "pBindInfo")]),
 
         Proto("VkResult", "CreateFence",
@@ -558,14 +558,14 @@ core = Extension(
         Proto("VkResult", "CreateGraphicsPipelines",
             [Param("VkDevice", "device"),
              Param("VkPipelineCache", "pipelineCache"),
-             Param("uint32_t", "count"),
+             Param("uint32_t", "createInfoCount"),
              Param("const VkGraphicsPipelineCreateInfo*", "pCreateInfos"),
              Param("VkPipeline*", "pPipelines")]),
 
         Proto("VkResult", "CreateComputePipelines",
             [Param("VkDevice", "device"),
              Param("VkPipelineCache", "pipelineCache"),
-             Param("uint32_t", "count"),
+             Param("uint32_t", "createInfoCount"),
              Param("const VkComputePipelineCreateInfo*", "pCreateInfos"),
              Param("VkPipeline*", "pPipelines")]),
 
@@ -622,7 +622,7 @@ core = Extension(
         Proto("VkResult", "FreeDescriptorSets",
             [Param("VkDevice", "device"),
              Param("VkDescriptorPool", "descriptorPool"),
-             Param("uint32_t", "count"),
+             Param("uint32_t", "descriptorSetCount"),
              Param("const VkDescriptorSet*", "pDescriptorSets")]),
 
         Proto("void", "UpdateDescriptorSets",
@@ -677,7 +677,7 @@ core = Extension(
         Proto("void", "FreeCommandBuffers",
             [Param("VkDevice", "device"),
              Param("VkCmdPool", "cmdPool"),
-             Param("uint32_t", "count"),
+             Param("uint32_t", "commandBufferCount"),
              Param("const VkCmdBuffer*", "pCommandBuffers")]),
 
         Proto("VkResult", "BeginCommandBuffer",
@@ -745,7 +745,7 @@ core = Extension(
              Param("VkPipelineBindPoint", "pipelineBindPoint"),
              Param("VkPipelineLayout", "layout"),
              Param("uint32_t", "firstSet"),
-             Param("uint32_t", "setCount"),
+             Param("uint32_t", "descriptorSetCount"),
              Param("const VkDescriptorSet*", "pDescriptorSets"),
              Param("uint32_t", "dynamicOffsetCount"),
              Param("const uint32_t*", "pDynamicOffsets")]),
@@ -782,14 +782,14 @@ core = Extension(
             [Param("VkCmdBuffer", "cmdBuffer"),
              Param("VkBuffer", "buffer"),
              Param("VkDeviceSize", "offset"),
-             Param("uint32_t", "count"),
+             Param("uint32_t", "drawCount"),
              Param("uint32_t", "stride")]),
 
         Proto("void", "CmdDrawIndexedIndirect",
             [Param("VkCmdBuffer", "cmdBuffer"),
              Param("VkBuffer", "buffer"),
              Param("VkDeviceSize", "offset"),
-             Param("uint32_t", "count"),
+             Param("uint32_t", "drawCount"),
              Param("uint32_t", "stride")]),
 
         Proto("void", "CmdDispatch",