diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
index 255ad97..7622e4d 100644
--- a/vulkan/libvulkan/entry.cpp
+++ b/vulkan/libvulkan/entry.cpp
@@ -42,13 +42,13 @@
 } // namespace
 
 __attribute__((visibility("default")))
-VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance) {
-    return vulkan::CreateInstance(pCreateInfo, pInstance);
+VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance) {
+    return vulkan::CreateInstance(pCreateInfo, pAllocator, pInstance);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyInstance(VkInstance instance) {
-    GetVtbl(instance).DestroyInstance(instance);
+void vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(instance).DestroyInstance(instance, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -72,8 +72,8 @@
 }
 
 __attribute__((visibility("default")))
-void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
-    GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pCount, pQueueFamilyProperties);
+void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
 }
 
 __attribute__((visibility("default")))
@@ -97,33 +97,33 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice) {
-    return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pDevice);
+VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice) {
+    return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyDevice(VkDevice device) {
-    vulkan::DestroyDevice(device);
+void vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator) {
+    vulkan::DestroyDevice(device, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkEnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties) {
-    return vulkan::EnumerateInstanceLayerProperties(pCount, pProperties);
+VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    return vulkan::EnumerateInstanceLayerProperties(pPropertyCount, pProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
-    return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pCount, pProperties);
+VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    return vulkan::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pCount, VkLayerProperties* pProperties) {
-    return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pCount, pProperties);
+VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {
+    return GetVtbl(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties) {
-    return GetVtbl(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
+VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {
+    return GetVtbl(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
 }
 
 __attribute__((visibility("default")))
@@ -147,13 +147,13 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) {
-    return GetVtbl(device).AllocMemory(device, pAllocInfo, pMem);
+VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem) {
+    return GetVtbl(device).AllocMemory(device, pAllocInfo, pAllocator, pMem);
 }
 
 __attribute__((visibility("default")))
-void vkFreeMemory(VkDevice device, VkDeviceMemory mem) {
-    GetVtbl(device).FreeMemory(device, mem);
+void vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).FreeMemory(device, mem, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -202,38 +202,38 @@
 }
 
 __attribute__((visibility("default")))
-void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
-    GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
+void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) {
+    GetVtbl(device).GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
 }
 
 __attribute__((visibility("default")))
-void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties) {
-    GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
+void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) {
+    GetVtbl(physicalDevice).GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
 }
 
 __attribute__((visibility("default")))
-VkResult vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
-    return GetVtbl(queue).QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
+VkResult vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
+    return GetVtbl(queue).QueueBindSparseBufferMemory(queue, buffer, bindInfoCount, pBindInfo);
 }
 
 __attribute__((visibility("default")))
-VkResult vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo) {
-    return GetVtbl(queue).QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
+VkResult vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseMemoryBindInfo* pBindInfo) {
+    return GetVtbl(queue).QueueBindSparseImageOpaqueMemory(queue, image, bindInfoCount, pBindInfo);
 }
 
 __attribute__((visibility("default")))
-VkResult vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo) {
-    return GetVtbl(queue).QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
+VkResult vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t bindInfoCount, const VkSparseImageMemoryBindInfo* pBindInfo) {
+    return GetVtbl(queue).QueueBindSparseImageMemory(queue, image, bindInfoCount, pBindInfo);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) {
-    return GetVtbl(device).CreateFence(device, pCreateInfo, pFence);
+VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence) {
+    return GetVtbl(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyFence(VkDevice device, VkFence fence) {
-    GetVtbl(device).DestroyFence(device, fence);
+void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyFence(device, fence, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -252,23 +252,23 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) {
-    return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pSemaphore);
+VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+    return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
 }
 
 __attribute__((visibility("default")))
-void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore) {
-    GetVtbl(device).DestroySemaphore(device, semaphore);
+void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroySemaphore(device, semaphore, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) {
-    return GetVtbl(device).CreateEvent(device, pCreateInfo, pEvent);
+VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent) {
+    return GetVtbl(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyEvent(VkDevice device, VkEvent event) {
-    GetVtbl(device).DestroyEvent(device, event);
+void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyEvent(device, event, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -287,13 +287,13 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) {
-    return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pQueryPool);
+VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+    return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool) {
-    GetVtbl(device).DestroyQueryPool(device, queryPool);
+void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyQueryPool(device, queryPool, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -302,33 +302,33 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) {
-    return GetVtbl(device).CreateBuffer(device, pCreateInfo, pBuffer);
+VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer) {
+    return GetVtbl(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyBuffer(VkDevice device, VkBuffer buffer) {
-    GetVtbl(device).DestroyBuffer(device, buffer);
+void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyBuffer(device, buffer, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) {
-    return GetVtbl(device).CreateBufferView(device, pCreateInfo, pView);
+VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView) {
+    return GetVtbl(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyBufferView(VkDevice device, VkBufferView bufferView) {
-    GetVtbl(device).DestroyBufferView(device, bufferView);
+void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyBufferView(device, bufferView, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) {
-    return GetVtbl(device).CreateImage(device, pCreateInfo, pImage);
+VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage) {
+    return GetVtbl(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyImage(VkDevice device, VkImage image) {
-    GetVtbl(device).DestroyImage(device, image);
+void vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyImage(device, image, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -337,43 +337,43 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) {
-    return GetVtbl(device).CreateImageView(device, pCreateInfo, pView);
+VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView) {
+    return GetVtbl(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyImageView(VkDevice device, VkImageView imageView) {
-    GetVtbl(device).DestroyImageView(device, imageView);
+void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyImageView(device, imageView, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) {
-    return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pShaderModule);
+VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+    return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule) {
-    GetVtbl(device).DestroyShaderModule(device, shaderModule);
+void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyShaderModule(device, shaderModule, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) {
-    return GetVtbl(device).CreateShader(device, pCreateInfo, pShader);
+VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader) {
+    return GetVtbl(device).CreateShader(device, pCreateInfo, pAllocator, pShader);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyShader(VkDevice device, VkShader shader) {
-    GetVtbl(device).DestroyShader(device, shader);
+void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyShader(device, shader, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) {
-    return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pPipelineCache);
+VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+    return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache) {
-    GetVtbl(device).DestroyPipelineCache(device, pipelineCache);
+void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -387,58 +387,58 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) {
-    return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
+    return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) {
-    return GetVtbl(device).CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
+VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
+    return GetVtbl(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyPipeline(VkDevice device, VkPipeline pipeline) {
-    GetVtbl(device).DestroyPipeline(device, pipeline);
+void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyPipeline(device, pipeline, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) {
-    return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
+VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+    return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout) {
-    GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout);
+void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) {
-    return GetVtbl(device).CreateSampler(device, pCreateInfo, pSampler);
+VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler) {
+    return GetVtbl(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
 }
 
 __attribute__((visibility("default")))
-void vkDestroySampler(VkDevice device, VkSampler sampler) {
-    GetVtbl(device).DestroySampler(device, sampler);
+void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroySampler(device, sampler, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) {
-    return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
+VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+    return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout) {
-    GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout);
+void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) {
-    return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pDescriptorPool);
+VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+    return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) {
-    GetVtbl(device).DestroyDescriptorPool(device, descriptorPool);
+void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -452,8 +452,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) {
-    return GetVtbl(device).FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
+VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) {
+    return GetVtbl(device).FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
 }
 
 __attribute__((visibility("default")))
@@ -462,23 +462,23 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) {
-    return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pFramebuffer);
+VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+    return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer) {
-    GetVtbl(device).DestroyFramebuffer(device, framebuffer);
+void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyFramebuffer(device, framebuffer, pAllocator);
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) {
-    return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pRenderPass);
+VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+    return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass) {
-    GetVtbl(device).DestroyRenderPass(device, renderPass);
+void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyRenderPass(device, renderPass, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -487,13 +487,13 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) {
-    return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pCmdPool);
+VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool) {
+    return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
 }
 
 __attribute__((visibility("default")))
-void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool) {
-    GetVtbl(device).DestroyCommandPool(device, cmdPool);
+void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator) {
+    GetVtbl(device).DestroyCommandPool(device, cmdPool, pAllocator);
 }
 
 __attribute__((visibility("default")))
@@ -507,8 +507,8 @@
 }
 
 __attribute__((visibility("default")))
-void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers) {
-    GetVtbl(device).FreeCommandBuffers(device, cmdPool, count, pCommandBuffers);
+void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers) {
+    GetVtbl(device).FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers);
 }
 
 __attribute__((visibility("default")))
@@ -577,8 +577,8 @@
 }
 
 __attribute__((visibility("default")))
-void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
-    GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+    GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
 __attribute__((visibility("default")))
@@ -602,13 +602,13 @@
 }
 
 __attribute__((visibility("default")))
-void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
-    GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride);
 }
 
 __attribute__((visibility("default")))
-void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
-    GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+    GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride);
 }
 
 __attribute__((visibility("default")))
@@ -722,8 +722,8 @@
 }
 
 __attribute__((visibility("default")))
-void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
-    GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, start, length, values);
+void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
+    GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
 }
 
 __attribute__((visibility("default")))
@@ -762,13 +762,13 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkSurfaceFormatKHR* pSurfaceFormats) {
-    return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pCount, pSurfaceFormats);
+VkResult vkGetSurfaceFormatsKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) {
+    return GetVtbl(device).GetSurfaceFormatsKHR(device, surface, pSurfaceFormatCount, pSurfaceFormats);
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pCount, VkPresentModeKHR* pPresentModes) {
-    return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pCount, pPresentModes);
+VkResult vkGetSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) {
+    return GetVtbl(device).GetSurfacePresentModesKHR(device, surface, pPresentModeCount, pPresentModes);
 }
 
 __attribute__((visibility("default")))
@@ -782,8 +782,8 @@
 }
 
 __attribute__((visibility("default")))
-VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pCount, VkImage* pSwapchainImages) {
-    return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pCount, pSwapchainImages);
+VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) {
+    return GetVtbl(device).GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
 }
 
 __attribute__((visibility("default")))
diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
index a44026f..10877c5 100644
--- a/vulkan/libvulkan/loader.cpp
+++ b/vulkan/libvulkan/loader.cpp
@@ -22,8 +22,8 @@
 #include <dirent.h>
 #include <dlfcn.h>
 #include <inttypes.h>
-#include <malloc.h>
 #include <pthread.h>
+#include <stdlib.h>
 #include <string.h>
 // standard C++ headers
 #include <algorithm>
@@ -58,7 +58,13 @@
 // Define Handle typedef to be void* as returned from dlopen.
 typedef void* SharedLibraryHandle;
 
-// Custom versions of std classes that use the vulkan alloc callback.
+// Standard-library allocator that delegates to VkAllocCallbacks.
+//
+// TODO(jessehall): This class currently always uses
+// VK_SYSTEM_ALLOC_SCOPE_INSTANCE. The scope to use could be a template
+// parameter or a constructor parameter. The former would help catch bugs
+// where we use the wrong scope, e.g. adding a command-scope string to an
+// instance-scope vector. But that might also be pretty annoying to deal with.
 template <class T>
 class CallbackAllocator {
    public:
@@ -73,7 +79,7 @@
 
     T* allocate(std::size_t n) {
         void* mem = alloc->pfnAlloc(alloc->pUserData, n * sizeof(T), alignof(T),
-                                    VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+                                    VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
         return static_cast<T*>(mem);
     }
 
@@ -208,8 +214,43 @@
     return *reinterpret_cast<DeviceVtbl**>(queue);
 }
 
-void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocType) {
-    return memalign(alignment, size);
+void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocScope) {
+    void* ptr = nullptr;
+    // Vulkan requires 'alignment' to be a power of two, but posix_memalign
+    // additionally requires that it be at least sizeof(void*).
+    return posix_memalign(&ptr, std::max(alignment, sizeof(void*)), size) == 0
+               ? ptr
+               : nullptr;
+}
+
+void* DefaultRealloc(void*,
+                     void* ptr,
+                     size_t size,
+                     size_t alignment,
+                     VkSystemAllocScope) {
+    if (size == 0) {
+        free(ptr);
+        return nullptr;
+    }
+
+    // TODO(jessehall): Right now we never shrink allocations; if the new
+    // request is smaller than the existing chunk, we just continue using it.
+    // Right now the loader never reallocs, so this doesn't matter. If that
+    // changes, or if this code is copied into some other project, this should
+    // probably have a heuristic to allocate-copy-free when doing so will save
+    // "enough" space.
+    size_t old_size = ptr ? malloc_usable_size(ptr) : 0;
+    if (size <= old_size)
+        return ptr;
+
+    void* new_ptr = nullptr;
+    if (posix_memalign(&new_ptr, alignment, size) != 0)
+        return nullptr;
+    if (ptr) {
+        memcpy(new_ptr, ptr, std::min(old_size, size));
+        free(ptr);
+    }
+    return new_ptr;
 }
 
 void DefaultFree(void*, void* pMem) {
@@ -219,6 +260,7 @@
 const VkAllocCallbacks kDefaultAllocCallbacks = {
     .pUserData = nullptr,
     .pfnAlloc = DefaultAlloc,
+    .pfnRealloc = DefaultRealloc,
     .pfnFree = DefaultFree,
 };
 
@@ -418,7 +460,7 @@
         }
     }
     // Load app layers
-    for (uint32_t i = 0; i < create_info->layerCount; ++i) {
+    for (uint32_t i = 0; i < create_info->enabledLayerNameCount; ++i) {
         String layer_name(create_info->ppEnabledLayerNames[i],
                           string_allocator);
         auto element = instance->layers.find(layer_name);
@@ -439,17 +481,18 @@
 bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
                               const char* extension_name,
                               const VkAllocCallbacks* alloc) {
-    for (uint32_t i = 0; i < local_create_info.extensionCount; ++i) {
+    for (uint32_t i = 0; i < local_create_info.enabledExtensionNameCount; ++i) {
         if (!strcmp(extension_name,
                     local_create_info.ppEnabledExtensionNames[i])) {
             return false;
         }
     }
-    uint32_t extension_count = local_create_info.extensionCount;
-    local_create_info.extensionCount++;
+    uint32_t extension_count = local_create_info.enabledExtensionNameCount;
+    local_create_info.enabledExtensionNameCount++;
     void* mem = alloc->pfnAlloc(
-        alloc->pUserData, local_create_info.extensionCount * sizeof(char*),
-        alignof(char*), VK_SYSTEM_ALLOC_TYPE_INTERNAL);
+        alloc->pUserData,
+        local_create_info.enabledExtensionNameCount * sizeof(char*),
+        alignof(char*), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (mem) {
         const char** enabled_extensions = static_cast<const char**>(mem);
         for (uint32_t i = 0; i < extension_count; ++i) {
@@ -461,7 +504,7 @@
     } else {
         ALOGW("%s extension cannot be enabled: memory allocation failed",
               extension_name);
-        local_create_info.extensionCount--;
+        local_create_info.enabledExtensionNameCount--;
         return false;
     }
     return true;
@@ -537,12 +580,14 @@
 // "Bottom" functions. These are called at the end of the instance dispatch
 // chain.
 
-void DestroyInstanceBottom(VkInstance instance) {
+void DestroyInstanceBottom(VkInstance instance,
+                           const VkAllocCallbacks* allocator) {
     // These checks allow us to call DestroyInstanceBottom from any error path
     // in CreateInstanceBottom, before the driver instance is fully initialized.
     if (instance->drv.vtbl.instance != VK_NULL_HANDLE &&
         instance->drv.vtbl.DestroyInstance) {
-        instance->drv.vtbl.DestroyInstance(instance->drv.vtbl.instance);
+        instance->drv.vtbl.DestroyInstance(instance->drv.vtbl.instance,
+                                           allocator);
     }
     if (instance->message) {
         PFN_vkDbgDestroyMsgCallback DebugDestroyMessageCallback;
@@ -561,21 +606,22 @@
 }
 
 VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
+                              const VkAllocCallbacks* allocator,
                               VkInstance* instance_ptr) {
     Instance* instance = *instance_ptr;
     VkResult result;
 
-    result =
-        g_hwdevice->CreateInstance(create_info, &instance->drv.vtbl.instance);
+    result = g_hwdevice->CreateInstance(create_info, instance->alloc,
+                                        &instance->drv.vtbl.instance);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return result;
     }
 
     if (!LoadInstanceVtbl(
             instance->drv.vtbl.instance, instance->drv.vtbl.instance,
             g_hwdevice->GetInstanceProcAddr, instance->drv.vtbl)) {
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
@@ -587,7 +633,7 @@
                                         "vkGetDeviceProcAddr"));
     if (!instance->drv.GetDeviceProcAddr) {
         ALOGE("missing instance proc: \"%s\"", "vkGetDeviceProcAddr");
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
@@ -600,7 +646,7 @@
     } else {
         ALOGE("invalid VkInstance dispatch magic: 0x%" PRIxPTR,
               dispatch->magic);
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
@@ -608,7 +654,7 @@
     result = instance->drv.vtbl.EnumeratePhysicalDevices(
         instance->drv.vtbl.instance, &num_physical_devices, nullptr);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
     num_physical_devices = std::min(num_physical_devices, kMaxPhysicalDevices);
@@ -616,7 +662,7 @@
         instance->drv.vtbl.instance, &num_physical_devices,
         instance->physical_devices);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
     for (uint32_t i = 0; i < num_physical_devices; i++) {
@@ -625,7 +671,7 @@
         if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC) {
             ALOGE("invalid VkPhysicalDevice dispatch magic: 0x%" PRIxPTR,
                   dispatch->magic);
-            DestroyInstanceBottom(instance);
+            DestroyInstanceBottom(instance, allocator);
             return VK_ERROR_INITIALIZATION_FAILED;
         }
         dispatch->vtbl = instance->vtbl;
@@ -696,13 +742,21 @@
 
 VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
                             const VkDeviceCreateInfo* create_info,
+                            const VkAllocCallbacks* allocator,
                             VkDevice* out_device) {
     Instance& instance = *static_cast<Instance*>(GetVtbl(pdev)->instance);
     VkResult result;
 
-    void* mem = instance.alloc->pfnAlloc(instance.alloc->pUserData,
-                                         sizeof(Device), alignof(Device),
-                                         VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+    if (!allocator) {
+        if (instance.alloc)
+            allocator = instance.alloc;
+        else
+            allocator = &kDefaultAllocCallbacks;
+    }
+
+    void* mem =
+        allocator->pfnAlloc(allocator->pUserData, sizeof(Device),
+                            alignof(Device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
     if (!mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     Device* device = new (mem) Device(&instance);
@@ -714,7 +768,8 @@
     }
 
     VkDevice drv_device;
-    result = instance.drv.vtbl.CreateDevice(pdev, create_info, &drv_device);
+    result = instance.drv.vtbl.CreateDevice(pdev, create_info, allocator,
+                                            &drv_device);
     if (result != VK_SUCCESS) {
         DestroyDevice(device);
         return result;
@@ -727,7 +782,7 @@
         PFN_vkDestroyDevice destroy_device =
             reinterpret_cast<PFN_vkDestroyDevice>(
                 instance.drv.GetDeviceProcAddr(drv_device, "vkDestroyDevice"));
-        destroy_device(drv_device);
+        destroy_device(drv_device, allocator);
         DestroyDevice(device);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
@@ -778,7 +833,7 @@
         reinterpret_cast<PFN_vkCreateDevice>(
             device->vtbl_storage.GetDeviceProcAddr(drv_device,
                                                    "vkCreateDevice"));
-    layer_createDevice(pdev, create_info, &drv_device);
+    layer_createDevice(pdev, create_info, allocator, &drv_device);
 
     // TODO(mlentine) : This is needed to use WSI layer validation. Remove this
     // when new version of layer initialization exits.
@@ -896,23 +951,25 @@
 }
 
 VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+                        const VkAllocCallbacks* allocator,
                         VkInstance* out_instance) {
     VkResult result;
 
     if (!EnsureInitialized())
         return VK_ERROR_INITIALIZATION_FAILED;
 
+    if (!allocator)
+        allocator = &kDefaultAllocCallbacks;
+
     VkInstanceCreateInfo local_create_info = *create_info;
-    if (!local_create_info.pAllocCb)
-        local_create_info.pAllocCb = &kDefaultAllocCallbacks;
     create_info = &local_create_info;
 
-    void* instance_mem = create_info->pAllocCb->pfnAlloc(
-        create_info->pAllocCb->pUserData, sizeof(Instance), alignof(Instance),
-        VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+    void* instance_mem =
+        allocator->pfnAlloc(allocator->pUserData, sizeof(Instance),
+                            alignof(Instance), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
     if (!instance_mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
-    Instance* instance = new (instance_mem) Instance(create_info->pAllocCb);
+    Instance* instance = new (instance_mem) Instance(allocator);
 
     instance->vtbl_storage = kBottomInstanceFunctions;
     instance->vtbl_storage.instance = instance;
@@ -930,7 +987,7 @@
 
     result = ActivateAllLayers(create_info, instance, instance);
     if (result != VK_SUCCESS) {
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return result;
     }
 
@@ -973,7 +1030,7 @@
     if (!LoadInstanceVtbl(static_cast<VkInstance>(base_object),
                           static_cast<VkInstance>(next_object),
                           next_get_proc_addr, instance->vtbl_storage)) {
-        DestroyInstanceBottom(instance);
+        DestroyInstanceBottom(instance, allocator);
         return VK_ERROR_INITIALIZATION_FAILED;
     }
 
@@ -988,7 +1045,8 @@
     }
 
     *out_instance = instance;
-    result = instance->vtbl_storage.CreateInstance(create_info, out_instance);
+    result = instance->vtbl_storage.CreateInstance(create_info, allocator,
+                                                   out_instance);
     if (enable_callback)
         FreeAllocatedCreateInfo(local_create_info, instance->alloc);
     if (result <= 0) {
@@ -1079,7 +1137,7 @@
     VkResult result = vtbl->AllocCommandBuffers(device, alloc_info, cmdbuffers);
     if (result != VK_SUCCESS)
         return result;
-    for (uint32_t i = 0; i < alloc_info->count; i++) {
+    for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
         hwvulkan_dispatch_t* dispatch =
             reinterpret_cast<hwvulkan_dispatch_t*>(cmdbuffers[i]);
         ALOGE_IF(dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
@@ -1090,14 +1148,15 @@
     return VK_SUCCESS;
 }
 
-VkResult DestroyDevice(VkDevice drv_device) {
+VkResult DestroyDevice(VkDevice drv_device,
+                       const VkAllocCallbacks* /*allocator*/) {
     const DeviceVtbl* vtbl = GetVtbl(drv_device);
     Device* device = static_cast<Device*>(vtbl->device);
     for (auto it = device->active_layers.begin();
          it != device->active_layers.end(); ++it) {
         DeactivateLayer(device->instance, it);
     }
-    vtbl->DestroyDevice(drv_device);
+    vtbl->DestroyDevice(drv_device, device->instance->alloc);
     DestroyDevice(device);
     return VK_SUCCESS;
 }
@@ -1105,9 +1164,9 @@
 void* AllocMem(VkInstance instance,
                size_t size,
                size_t align,
-               VkSystemAllocType type) {
+               VkSystemAllocScope scope) {
     const VkAllocCallbacks* alloc_cb = instance->alloc;
-    return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
+    return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
 }
 
 void FreeMem(VkInstance instance, void* ptr) {
@@ -1118,10 +1177,10 @@
 void* AllocMem(VkDevice device,
                size_t size,
                size_t align,
-               VkSystemAllocType type) {
+               VkSystemAllocScope scope) {
     const VkAllocCallbacks* alloc_cb =
         static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
-    return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, type);
+    return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
 }
 
 void FreeMem(VkDevice device, void* ptr) {
diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
index 15e2779..e166887 100644
--- a/vulkan/libvulkan/loader.h
+++ b/vulkan/libvulkan/loader.h
@@ -216,6 +216,7 @@
 VkResult EnumerateInstanceLayerProperties(uint32_t* count,
                                           VkLayerProperties* properties);
 VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
+                        const VkAllocCallbacks* pAllocator,
                         VkInstance* instance);
 PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
 PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
@@ -226,17 +227,17 @@
 VkResult AllocCommandBuffers(VkDevice device,
                              const VkCmdBufferAllocInfo* alloc_info,
                              VkCmdBuffer* cmdbuffers);
-VkResult DestroyDevice(VkDevice drv_device);
+VkResult DestroyDevice(VkDevice drv_device, const VkAllocCallbacks* pAllocator);
 
 void* AllocMem(VkInstance instance,
                size_t size,
                size_t align,
-               VkSystemAllocType type);
+               VkSystemAllocScope scope);
 void FreeMem(VkInstance instance, void* ptr);
 void* AllocMem(VkDevice device,
                size_t size,
                size_t align,
-               VkSystemAllocType type);
+               VkSystemAllocScope scope);
 void FreeMem(VkDevice device, void* ptr);
 const DeviceVtbl& GetDriverVtbl(VkDevice device);
 const DeviceVtbl& GetDriverVtbl(VkQueue queue);
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index 2922465..f6ab081 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -49,6 +49,19 @@
     void operator()(T* obj) { obj->common.decRef(&obj->common); }
 };
 
+template <typename Host>
+struct AllocScope {};
+
+template <>
+struct AllocScope<VkInstance> {
+    static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_INSTANCE;
+};
+
+template <>
+struct AllocScope<VkDevice> {
+    static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_DEVICE;
+};
+
 template <typename T, typename Host>
 class VulkanAllocator {
    public:
@@ -62,7 +75,7 @@
 
     T* allocate(size_t n) const {
         return static_cast<T*>(AllocMem(host_, n * sizeof(T), alignof(T),
-                                        VK_SYSTEM_ALLOC_TYPE_INTERNAL));
+                                        AllocScope<Host>::kScope));
     }
     void deallocate(T* p, size_t) const { return FreeMem(host_, p); }
 
@@ -129,7 +142,7 @@
                                  ANativeWindow* window,
                                  VkSurfaceKHR* out_surface) {
     void* mem = AllocMem(instance, sizeof(Surface), alignof(Surface),
-                         VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+                         VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     Surface* surface = new (mem) Surface;
@@ -362,7 +375,7 @@
     // After this point, we must deallocate the swapchain on error.
 
     void* mem = AllocMem(device, sizeof(Swapchain), alignof(Swapchain),
-                         VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+                         VK_SYSTEM_ALLOC_SCOPE_OBJECT);
     if (!mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
     Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
@@ -391,7 +404,7 @@
         .usage = create_info->imageUsageFlags,
         .flags = 0,
         .sharingMode = create_info->sharingMode,
-        .queueFamilyCount = create_info->queueFamilyCount,
+        .queueFamilyIndexCount = create_info->queueFamilyIndexCount,
         .pQueueFamilyIndices = create_info->pQueueFamilyIndices,
     };
 
@@ -418,7 +431,8 @@
         image_native_buffer.format = img.buffer->format;
         image_native_buffer.usage = img.buffer->usage;
 
-        result = driver_vtbl.CreateImage(device, &image_create, &img.image);
+        result =
+            driver_vtbl.CreateImage(device, &image_create, nullptr, &img.image);
         if (result != VK_SUCCESS) {
             ALOGD("vkCreateImage w/ native buffer failed: %u", result);
             break;
@@ -441,7 +455,7 @@
         }
         if (result != VK_SUCCESS) {
             if (img.image)
-                driver_vtbl.DestroyImage(device, img.image);
+                driver_vtbl.DestroyImage(device, img.image, nullptr);
         }
     }
 
@@ -469,7 +483,7 @@
             img.dequeued = false;
         }
         if (img.image) {
-            driver_vtbl.DestroyImage(device, img.image);
+            driver_vtbl.DestroyImage(device, img.image, nullptr);
         }
     }
 
@@ -592,7 +606,7 @@
     VkResult final_result = VK_SUCCESS;
     for (uint32_t sc = 0; sc < present_info->swapchainCount; sc++) {
         Swapchain& swapchain =
-            *SwapchainFromHandle(present_info->swapchains[sc]);
+            *SwapchainFromHandle(present_info->pSwapchains[sc]);
         ANativeWindow* window = swapchain.surface.window.get();
         uint32_t image_idx = present_info->imageIndices[sc];
         Swapchain::Image& img = swapchain.images[image_idx];