diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
index 698dbd0..d134c0e 100644
--- a/vulkan/nulldrv/null_driver.cpp
+++ b/vulkan/nulldrv/null_driver.cpp
@@ -35,7 +35,7 @@
 
 struct VkInstance_T {
     hwvulkan_dispatch_t dispatch;
-    VkAllocCallbacks allocator;
+    VkAllocationCallbacks allocator;
     VkPhysicalDevice_T physical_device;
 };
 
@@ -43,7 +43,7 @@
     hwvulkan_dispatch_t dispatch;
 };
 
-struct VkCmdBuffer_T {
+struct VkCommandBuffer_T {
     hwvulkan_dispatch_t dispatch;
 };
 
@@ -95,7 +95,7 @@
 
 struct VkDevice_T {
     hwvulkan_dispatch_t dispatch;
-    VkAllocCallbacks allocator;
+    VkAllocationCallbacks allocator;
     VkInstance_T* instance;
     VkQueue_T queue;
     std::array<uint64_t, HandleType::kNumTypes> next_handle;
@@ -131,16 +131,17 @@
 namespace {
 
 VkResult CreateInstance(const VkInstanceCreateInfo* /*create_info*/,
-                        const VkAllocCallbacks* allocator,
+                        const VkAllocationCallbacks* allocator,
                         VkInstance* out_instance) {
     // Assume the loader provided alloc callbacks even if the app didn't.
     ALOG_ASSERT(
         allocator,
         "Missing alloc callbacks, loader or app should have provided them");
 
-    VkInstance_T* instance = static_cast<VkInstance_T*>(allocator->pfnAlloc(
-        allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
-        VK_SYSTEM_ALLOC_SCOPE_INSTANCE));
+    VkInstance_T* instance =
+        static_cast<VkInstance_T*>(allocator->pfnAllocation(
+            allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
+            VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
     if (!instance)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -245,7 +246,7 @@
 // Instance
 
 void DestroyInstance(VkInstance instance,
-                     const VkAllocCallbacks* /*allocator*/) {
+                     const VkAllocationCallbacks* /*allocator*/) {
     instance->allocator.pfnFree(instance->allocator.pUserData, instance);
 }
 
@@ -303,14 +304,14 @@
 
 VkResult CreateDevice(VkPhysicalDevice physical_device,
                       const VkDeviceCreateInfo*,
-                      const VkAllocCallbacks* allocator,
+                      const VkAllocationCallbacks* allocator,
                       VkDevice* out_device) {
     VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
     if (!allocator)
         allocator = &instance->allocator;
-    VkDevice_T* device = static_cast<VkDevice_T*>(
-        allocator->pfnAlloc(allocator->pUserData, sizeof(VkDevice_T),
-                            alignof(VkDevice_T), VK_SYSTEM_ALLOC_SCOPE_DEVICE));
+    VkDevice_T* device = static_cast<VkDevice_T*>(allocator->pfnAllocation(
+        allocator->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
+        VK_SYSTEM_ALLOCATION_SCOPE_DEVICE));
     if (!device)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
@@ -325,7 +326,8 @@
     return VK_SUCCESS;
 }
 
-void DestroyDevice(VkDevice device, const VkAllocCallbacks* /*allocator*/) {
+void DestroyDevice(VkDevice device,
+                   const VkAllocationCallbacks* /*allocator*/) {
     if (!device)
         return;
     device->allocator.pfnFree(device->allocator.pUserData, device);
@@ -336,50 +338,51 @@
 }
 
 // -----------------------------------------------------------------------------
-// CmdPool
+// CommandPool
 
-struct CmdPool {
-    typedef VkCmdPool HandleType;
-    VkAllocCallbacks allocator;
+struct CommandPool {
+    typedef VkCommandPool HandleType;
+    VkAllocationCallbacks allocator;
 };
-DEFINE_OBJECT_HANDLE_CONVERSION(CmdPool)
+DEFINE_OBJECT_HANDLE_CONVERSION(CommandPool)
 
 VkResult CreateCommandPool(VkDevice device,
-                           const VkCmdPoolCreateInfo* /*create_info*/,
-                           const VkAllocCallbacks* allocator,
-                           VkCmdPool* cmd_pool) {
+                           const VkCommandPoolCreateInfo* /*create_info*/,
+                           const VkAllocationCallbacks* allocator,
+                           VkCommandPool* cmd_pool) {
     if (!allocator)
         allocator = &device->allocator;
-    CmdPool* pool = static_cast<CmdPool*>(
-        allocator->pfnAlloc(allocator->pUserData, sizeof(CmdPool),
-                            alignof(CmdPool), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+    CommandPool* pool = static_cast<CommandPool*>(allocator->pfnAllocation(
+        allocator->pUserData, sizeof(CommandPool), alignof(CommandPool),
+        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
     if (!pool)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     pool->allocator = *allocator;
-    *cmd_pool = GetHandleToCmdPool(pool);
+    *cmd_pool = GetHandleToCommandPool(pool);
     return VK_SUCCESS;
 }
 
 void DestroyCommandPool(VkDevice /*device*/,
-                        VkCmdPool cmd_pool,
-                        const VkAllocCallbacks* /*allocator*/) {
-    CmdPool* pool = GetCmdPoolFromHandle(cmd_pool);
+                        VkCommandPool cmd_pool,
+                        const VkAllocationCallbacks* /*allocator*/) {
+    CommandPool* pool = GetCommandPoolFromHandle(cmd_pool);
     pool->allocator.pfnFree(pool->allocator.pUserData, pool);
 }
 
 // -----------------------------------------------------------------------------
 // CmdBuffer
 
-VkResult AllocCommandBuffers(VkDevice /*device*/,
-                             const VkCmdBufferAllocInfo* alloc_info,
-                             VkCmdBuffer* cmdbufs) {
+VkResult AllocateCommandBuffers(VkDevice /*device*/,
+                                const VkCommandBufferAllocateInfo* alloc_info,
+                                VkCommandBuffer* cmdbufs) {
     VkResult result = VK_SUCCESS;
-    CmdPool& pool = *GetCmdPoolFromHandle(alloc_info->cmdPool);
+    CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
     std::fill(cmdbufs, cmdbufs + alloc_info->bufferCount, nullptr);
     for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
-        cmdbufs[i] = static_cast<VkCmdBuffer_T*>(pool.allocator.pfnAlloc(
-            pool.allocator.pUserData, sizeof(VkCmdBuffer_T),
-            alignof(VkCmdBuffer_T), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+        cmdbufs[i] =
+            static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
+                pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
+                alignof(VkCommandBuffer_T), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
         if (!cmdbufs[i]) {
             result = VK_ERROR_OUT_OF_HOST_MEMORY;
             break;
@@ -397,10 +400,10 @@
 }
 
 void FreeCommandBuffers(VkDevice /*device*/,
-                        VkCmdPool cmd_pool,
+                        VkCommandPool cmd_pool,
                         uint32_t count,
-                        const VkCmdBuffer* cmdbufs) {
-    CmdPool& pool = *GetCmdPoolFromHandle(cmd_pool);
+                        const VkCommandBuffer* cmdbufs) {
+    CommandPool& pool = *GetCommandPoolFromHandle(cmd_pool);
     for (uint32_t i = 0; i < count; i++)
         pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
 }
@@ -415,19 +418,19 @@
 };
 DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
 
-VkResult AllocMemory(VkDevice device,
-                     const VkMemoryAllocInfo* alloc_info,
-                     const VkAllocCallbacks* allocator,
-                     VkDeviceMemory* mem_handle) {
+VkResult AllocateMemory(VkDevice device,
+                        const VkMemoryAllocateInfo* alloc_info,
+                        const VkAllocationCallbacks* allocator,
+                        VkDeviceMemory* mem_handle) {
     if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     if (!allocator)
         allocator = &device->allocator;
 
     size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
-    DeviceMemory* mem = static_cast<DeviceMemory*>(
-        allocator->pfnAlloc(allocator->pUserData, size, alignof(DeviceMemory),
-                            VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+    DeviceMemory* mem = static_cast<DeviceMemory*>(allocator->pfnAllocation(
+        allocator->pUserData, size, alignof(DeviceMemory),
+        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
     if (!mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     mem->size = size;
@@ -437,7 +440,7 @@
 
 void FreeMemory(VkDevice device,
                 VkDeviceMemory mem_handle,
-                const VkAllocCallbacks* allocator) {
+                const VkAllocationCallbacks* allocator) {
     if (!allocator)
         allocator = &device->allocator;
     DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
@@ -466,7 +469,7 @@
 
 VkResult CreateBuffer(VkDevice device,
                       const VkBufferCreateInfo* create_info,
-                      const VkAllocCallbacks* allocator,
+                      const VkAllocationCallbacks* allocator,
                       VkBuffer* buffer_handle) {
     ALOGW_IF(create_info->size > kMaxDeviceMemory,
              "CreateBuffer: requested size 0x%" PRIx64
@@ -474,9 +477,9 @@
              create_info->size, kMaxDeviceMemory);
     if (!allocator)
         allocator = &device->allocator;
-    Buffer* buffer = static_cast<Buffer*>(
-        allocator->pfnAlloc(allocator->pUserData, sizeof(Buffer),
-                            alignof(Buffer), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+    Buffer* buffer = static_cast<Buffer*>(allocator->pfnAllocation(
+        allocator->pUserData, sizeof(Buffer), alignof(Buffer),
+        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
     if (!buffer)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     buffer->size = create_info->size;
@@ -495,7 +498,7 @@
 
 void DestroyBuffer(VkDevice device,
                    VkBuffer buffer_handle,
-                   const VkAllocCallbacks* allocator) {
+                   const VkAllocationCallbacks* allocator) {
     if (!allocator)
         allocator = &device->allocator;
     Buffer* buffer = GetBufferFromHandle(buffer_handle);
@@ -513,7 +516,7 @@
 
 VkResult CreateImage(VkDevice device,
                      const VkImageCreateInfo* create_info,
-                     const VkAllocCallbacks* allocator,
+                     const VkAllocationCallbacks* allocator,
                      VkImage* image_handle) {
     if (create_info->imageType != VK_IMAGE_TYPE_2D ||
         create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
@@ -534,9 +537,9 @@
 
     if (!allocator)
         allocator = &device->allocator;
-    Image* image = static_cast<Image*>(
-        allocator->pfnAlloc(allocator->pUserData, sizeof(Image), alignof(Image),
-                            VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+    Image* image = static_cast<Image*>(allocator->pfnAllocation(
+        allocator->pUserData, sizeof(Image), alignof(Image),
+        VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
     if (!image)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     image->size = size;
@@ -555,7 +558,7 @@
 
 void DestroyImage(VkDevice device,
                   VkImage image_handle,
-                  const VkAllocCallbacks* allocator) {
+                  const VkAllocationCallbacks* allocator) {
     if (!allocator)
         allocator = &device->allocator;
     Image* image = GetImageFromHandle(image_handle);
@@ -567,7 +570,7 @@
 
 VkResult CreateBufferView(VkDevice device,
                           const VkBufferViewCreateInfo*,
-                          const VkAllocCallbacks* /*allocator*/,
+                          const VkAllocationCallbacks* /*allocator*/,
                           VkBufferView* view) {
     *view = AllocHandle(device, HandleType::kBufferView);
     return VK_SUCCESS;
@@ -575,15 +578,15 @@
 
 VkResult CreateDescriptorPool(VkDevice device,
                               const VkDescriptorPoolCreateInfo*,
-                              const VkAllocCallbacks* /*allocator*/,
+                              const VkAllocationCallbacks* /*allocator*/,
                               VkDescriptorPool* pool) {
     *pool = AllocHandle(device, HandleType::kDescriptorPool);
     return VK_SUCCESS;
 }
 
-VkResult AllocDescriptorSets(VkDevice device,
-                             const VkDescriptorSetAllocInfo* alloc_info,
-                             VkDescriptorSet* descriptor_sets) {
+VkResult AllocateDescriptorSets(VkDevice device,
+                                const VkDescriptorSetAllocateInfo* alloc_info,
+                                VkDescriptorSet* descriptor_sets) {
     for (uint32_t i = 0; i < alloc_info->setLayoutCount; i++)
         descriptor_sets[i] = AllocHandle(device, HandleType::kDescriptorSet);
     return VK_SUCCESS;
@@ -591,7 +594,7 @@
 
 VkResult CreateDescriptorSetLayout(VkDevice device,
                                    const VkDescriptorSetLayoutCreateInfo*,
-                                   const VkAllocCallbacks* /*allocator*/,
+                                   const VkAllocationCallbacks* /*allocator*/,
                                    VkDescriptorSetLayout* layout) {
     *layout = AllocHandle(device, HandleType::kDescriptorSetLayout);
     return VK_SUCCESS;
@@ -599,7 +602,7 @@
 
 VkResult CreateEvent(VkDevice device,
                      const VkEventCreateInfo*,
-                     const VkAllocCallbacks* /*allocator*/,
+                     const VkAllocationCallbacks* /*allocator*/,
                      VkEvent* event) {
     *event = AllocHandle(device, HandleType::kEvent);
     return VK_SUCCESS;
@@ -607,7 +610,7 @@
 
 VkResult CreateFence(VkDevice device,
                      const VkFenceCreateInfo*,
-                     const VkAllocCallbacks* /*allocator*/,
+                     const VkAllocationCallbacks* /*allocator*/,
                      VkFence* fence) {
     *fence = AllocHandle(device, HandleType::kFence);
     return VK_SUCCESS;
@@ -615,7 +618,7 @@
 
 VkResult CreateFramebuffer(VkDevice device,
                            const VkFramebufferCreateInfo*,
-                           const VkAllocCallbacks* /*allocator*/,
+                           const VkAllocationCallbacks* /*allocator*/,
                            VkFramebuffer* framebuffer) {
     *framebuffer = AllocHandle(device, HandleType::kFramebuffer);
     return VK_SUCCESS;
@@ -623,7 +626,7 @@
 
 VkResult CreateImageView(VkDevice device,
                          const VkImageViewCreateInfo*,
-                         const VkAllocCallbacks* /*allocator*/,
+                         const VkAllocationCallbacks* /*allocator*/,
                          VkImageView* view) {
     *view = AllocHandle(device, HandleType::kImageView);
     return VK_SUCCESS;
@@ -633,7 +636,7 @@
                                  VkPipelineCache,
                                  uint32_t count,
                                  const VkGraphicsPipelineCreateInfo*,
-                                 const VkAllocCallbacks* /*allocator*/,
+                                 const VkAllocationCallbacks* /*allocator*/,
                                  VkPipeline* pipelines) {
     for (uint32_t i = 0; i < count; i++)
         pipelines[i] = AllocHandle(device, HandleType::kPipeline);
@@ -644,7 +647,7 @@
                                 VkPipelineCache,
                                 uint32_t count,
                                 const VkComputePipelineCreateInfo*,
-                                const VkAllocCallbacks* /*allocator*/,
+                                const VkAllocationCallbacks* /*allocator*/,
                                 VkPipeline* pipelines) {
     for (uint32_t i = 0; i < count; i++)
         pipelines[i] = AllocHandle(device, HandleType::kPipeline);
@@ -653,7 +656,7 @@
 
 VkResult CreatePipelineCache(VkDevice device,
                              const VkPipelineCacheCreateInfo*,
-                             const VkAllocCallbacks* /*allocator*/,
+                             const VkAllocationCallbacks* /*allocator*/,
                              VkPipelineCache* cache) {
     *cache = AllocHandle(device, HandleType::kPipelineCache);
     return VK_SUCCESS;
@@ -661,7 +664,7 @@
 
 VkResult CreatePipelineLayout(VkDevice device,
                               const VkPipelineLayoutCreateInfo*,
-                              const VkAllocCallbacks* /*allocator*/,
+                              const VkAllocationCallbacks* /*allocator*/,
                               VkPipelineLayout* layout) {
     *layout = AllocHandle(device, HandleType::kPipelineLayout);
     return VK_SUCCESS;
@@ -669,7 +672,7 @@
 
 VkResult CreateQueryPool(VkDevice device,
                          const VkQueryPoolCreateInfo*,
-                         const VkAllocCallbacks* /*allocator*/,
+                         const VkAllocationCallbacks* /*allocator*/,
                          VkQueryPool* pool) {
     *pool = AllocHandle(device, HandleType::kQueryPool);
     return VK_SUCCESS;
@@ -677,7 +680,7 @@
 
 VkResult CreateRenderPass(VkDevice device,
                           const VkRenderPassCreateInfo*,
-                          const VkAllocCallbacks* /*allocator*/,
+                          const VkAllocationCallbacks* /*allocator*/,
                           VkRenderPass* renderpass) {
     *renderpass = AllocHandle(device, HandleType::kRenderPass);
     return VK_SUCCESS;
@@ -685,7 +688,7 @@
 
 VkResult CreateSampler(VkDevice device,
                        const VkSamplerCreateInfo*,
-                       const VkAllocCallbacks* /*allocator*/,
+                       const VkAllocationCallbacks* /*allocator*/,
                        VkSampler* sampler) {
     *sampler = AllocHandle(device, HandleType::kSampler);
     return VK_SUCCESS;
@@ -693,7 +696,7 @@
 
 VkResult CreateSemaphore(VkDevice device,
                          const VkSemaphoreCreateInfo*,
-                         const VkAllocCallbacks* /*allocator*/,
+                         const VkAllocationCallbacks* /*allocator*/,
                          VkSemaphore* semaphore) {
     *semaphore = AllocHandle(device, HandleType::kSemaphore);
     return VK_SUCCESS;
@@ -701,7 +704,7 @@
 
 VkResult CreateShader(VkDevice device,
                       const VkShaderCreateInfo*,
-                      const VkAllocCallbacks* /*allocator*/,
+                      const VkAllocationCallbacks* /*allocator*/,
                       VkShader* shader) {
     *shader = AllocHandle(device, HandleType::kShader);
     return VK_SUCCESS;
@@ -709,7 +712,7 @@
 
 VkResult CreateShaderModule(VkDevice device,
                             const VkShaderModuleCreateInfo*,
-                            const VkAllocCallbacks* /*allocator*/,
+                            const VkAllocationCallbacks* /*allocator*/,
                             VkShaderModule* module) {
     *module = AllocHandle(device, HandleType::kShaderModule);
     return VK_SUCCESS;
@@ -820,7 +823,7 @@
     return VK_SUCCESS;
 }
 
-void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator) {
+void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator) {
 }
 
 VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
@@ -836,10 +839,10 @@
     return VK_SUCCESS;
 }
 
-void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator) {
+void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator) {
+void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator) {
 }
 
 VkResult GetEventStatus(VkDevice device, VkEvent event) {
@@ -857,7 +860,7 @@
     return VK_SUCCESS;
 }
 
-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator) {
+void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator) {
 }
 
 VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
@@ -865,23 +868,23 @@
     return VK_SUCCESS;
 }
 
-void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator) {
+void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator) {
 }
 
 void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
     ALOGV("TODO: vk%s", __FUNCTION__);
 }
 
-void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator) {
+void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator) {
+void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator) {
+void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator) {
+void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator) {
 }
 
 VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
@@ -894,19 +897,19 @@
     return VK_SUCCESS;
 }
 
-void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator) {
+void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator) {
+void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator) {
+void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator) {
+void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator) {
+void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator) {
 }
 
 VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
@@ -923,164 +926,164 @@
     return VK_SUCCESS;
 }
 
-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator) {
+void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator) {
 }
 
-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator) {
+void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator) {
 }
 
 void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
     ALOGV("TODO: vk%s", __FUNCTION__);
 }
 
-VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
+VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags) {
     ALOGV("TODO: vk%s", __FUNCTION__);
     return VK_SUCCESS;
 }
 
-VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) {
+VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
     return VK_SUCCESS;
 }
 
-VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer) {
+VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer) {
     return VK_SUCCESS;
 }
 
-VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) {
+VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags) {
     ALOGV("TODO: vk%s", __FUNCTION__);
     return VK_SUCCESS;
 }
 
-void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
 }
 
-void CmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
 }
 
-void CmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
 }
 
-void CmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth) {
+void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth) {
 }
 
-void CmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
+void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
 }
 
-void CmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]) {
+void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]) {
 }
 
-void CmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
+void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
 }
 
-void CmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
+void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
 }
 
-void CmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
+void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
 }
 
-void CmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
+void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
 }
 
-void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
 }
 
-void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
 }
 
-void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
 }
 
-void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
 }
 
-void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
 }
 
-void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
 }
 
-void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
 }
 
-void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
+void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
 }
 
-void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
+void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
 }
 
-void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
 }
 
-void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
 }
 
-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
 }
 
-void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
 }
 
-void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
 }
 
-void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
 }
 
-void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
+void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
 }
 
-void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
 }
 
-void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
 }
 
-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
 }
 
-void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
 }
 
-void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
 }
 
-void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
 }
 
-void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
 }
 
-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
 }
 
-void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
+void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
 }
 
-void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
+void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
 }
 
-void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
 }
 
-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
 }
 
-void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
+void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
 }
 
-void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
+void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
 }
 
-void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
+void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
 }
 
-void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) {
+void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents) {
 }
 
-void CmdEndRenderPass(VkCmdBuffer cmdBuffer) {
+void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
 }
 
-void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) {
+void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers) {
 }
 
 #pragma clang diagnostic pop
diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
index 5f3e53e..939a559 100644
--- a/vulkan/nulldrv/null_driver.h
+++ b/vulkan/nulldrv/null_driver.h
@@ -27,7 +27,7 @@
 PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);
 
 // clang-format off
-void DestroyInstance(VkInstance instance, const VkAllocCallbacks* allocator);
+void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* allocator);
 VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
 void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
 void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
@@ -37,8 +37,8 @@
 void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
 PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
 PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
-VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDevice* pDevice);
-void DestroyDevice(VkDevice device, const VkAllocCallbacks* allocator);
+VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDevice* pDevice);
+void DestroyDevice(VkDevice device, const VkAllocationCallbacks* allocator);
 VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
 VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
 VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
@@ -47,8 +47,8 @@
 VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
 VkResult QueueWaitIdle(VkQueue queue);
 VkResult DeviceWaitIdle(VkDevice device);
-VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* allocator, VkDeviceMemory* pMem);
-void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* allocator);
+VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocInfo, const VkAllocationCallbacks* allocator, VkDeviceMemory* pMem);
+void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* allocator);
 VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
 void UnmapMemory(VkDevice device, VkDeviceMemory mem);
 VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
@@ -61,110 +61,110 @@
 void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
 void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
 VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
-VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFence* pFence);
-void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator);
+VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFence* pFence);
+void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator);
 VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
 VkResult GetFenceStatus(VkDevice device, VkFence fence);
 VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
-VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSemaphore* pSemaphore);
-void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator);
-VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkEvent* pEvent);
-void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator);
+VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSemaphore* pSemaphore);
+void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator);
+VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkEvent* pEvent);
+void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator);
 VkResult GetEventStatus(VkDevice device, VkEvent event);
 VkResult SetEvent(VkDevice device, VkEvent event);
 VkResult ResetEvent(VkDevice device, VkEvent event);
-VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkQueryPool* pQueryPool);
-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator);
+VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkQueryPool* pQueryPool);
+void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator);
 VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
-VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBuffer* pBuffer);
-void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* allocator);
-VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBufferView* pView);
-void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator);
-VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImage* pImage);
-void DestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* allocator);
+VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBuffer* pBuffer);
+void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* allocator);
+VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBufferView* pView);
+void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator);
+VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImage* pImage);
+void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* allocator);
 void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
-VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImageView* pView);
-void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator);
-VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShaderModule* pShaderModule);
-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator);
-VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShader* pShader);
-void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator);
-VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineCache* pPipelineCache);
-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator);
+VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImageView* pView);
+void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator);
+VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShaderModule* pShaderModule);
+void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator);
+VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShader* pShader);
+void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator);
+VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineCache* pPipelineCache);
+void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator);
 VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
 VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
-VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
-void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator);
-VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator);
-VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSampler* pSampler);
-void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator);
-VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator);
-VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator);
+VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
+VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
+void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator);
+VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
+void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator);
+VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSampler* pSampler);
+void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator);
+VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
+void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator);
+VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
+void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator);
 VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
-VkResult AllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
 VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
 void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
-VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFramebuffer* pFramebuffer);
-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator);
-VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkRenderPass* pRenderPass);
-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator);
+VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFramebuffer* pFramebuffer);
+void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator);
+VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkRenderPass* pRenderPass);
+void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator);
 void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
-VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkCmdPool* pCmdPool);
-void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* allocator);
-VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
-VkResult AllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
-void FreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
-VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
-VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer);
-VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
-void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-void CmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
-void CmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
-void CmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth);
-void CmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
-void CmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]);
-void CmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
-void CmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
-void CmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
-void CmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
-void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
-void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
-void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
-void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
-void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
-void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
-void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
-void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
-void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
-void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
-void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
-void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
-void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
-void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
-void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
-void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
-void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
-void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
-void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
-void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
-void CmdEndRenderPass(VkCmdBuffer cmdBuffer);
-void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
+VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkCommandPool* pCmdPool);
+void DestroyCommandPool(VkDevice device, VkCommandPool cmdPool, const VkAllocationCallbacks* allocator);
+VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags);
+VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocInfo, VkCommandBuffer* pCmdBuffers);
+void FreeCommandBuffers(VkDevice device, VkCommandPool cmdPool, uint32_t count, const VkCommandBuffer* pCommandBuffers);
+VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer);
+VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags);
+void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth);
+void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
+void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]);
+void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents);
+void CmdEndRenderPass(VkCommandBuffer cmdBuffer);
+void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers);
 
 VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
 VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
index f836a70..9b1b042 100644
--- a/vulkan/nulldrv/null_driver_gen.cpp
+++ b/vulkan/nulldrv/null_driver_gen.cpp
@@ -67,9 +67,9 @@
 
 const NameProcEntry kDeviceProcTbl[] = {
     // clang-format off
-    {"vkAllocCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocCommandBuffers>(AllocCommandBuffers))},
-    {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocDescriptorSets>(AllocDescriptorSets))},
-    {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocMemory>(AllocMemory))},
+    {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers))},
+    {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateDescriptorSets>(AllocateDescriptorSets))},
+    {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateMemory>(AllocateMemory))},
     {"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBeginCommandBuffer>(BeginCommandBuffer))},
     {"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBindBufferMemory>(BindBufferMemory))},
     {"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBindImageMemory>(BindImageMemory))},