diff --git a/include/vkLayer.h b/include/vkLayer.h
index bd56f03..7239ba5 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -55,9 +55,9 @@
     PFN_vkOpenPeerImage OpenPeerImage;
     PFN_vkDestroyObject DestroyObject;
     PFN_vkGetObjectInfo GetObjectInfo;
-    PFN_vkQueueBindObjectMemory QueueBindObjectMemory;
-    PFN_vkQueueBindObjectMemoryRange QueueBindObjectMemoryRange;
-    PFN_vkQueueBindImageMemoryRange QueueBindImageMemoryRange;
+    PFN_vkBindObjectMemory BindObjectMemory;
+    PFN_vkQueueBindSparseBufferMemory QueueBindSparseBufferMemory;
+    PFN_vkQueueBindSparseImageMemory QueueBindSparseImageMemory;
     PFN_vkCreateFence CreateFence;
     PFN_vkGetFenceStatus GetFenceStatus;
     PFN_vkResetFences ResetFences;
diff --git a/include/vulkan.h b/include/vulkan.h
index e85ca9d..8829222 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -970,7 +970,7 @@
     VK_QUEUE_GRAPHICS_BIT                                   = VK_BIT(0),    // Queue supports graphics operations
     VK_QUEUE_COMPUTE_BIT                                    = VK_BIT(1),    // Queue supports compute operations
     VK_QUEUE_DMA_BIT                                        = VK_BIT(2),    // Queue supports DMA operations
-    VK_QUEUE_MEMMGR_BIT                                     = VK_BIT(3),    // Queue supports memory management operations
+    VK_QUEUE_SPARSE_MEMMGR_BIT                              = VK_BIT(3),    // Queue supports sparse resource memory management operations
     VK_QUEUE_EXTENDED_BIT                                   = VK_BIT(30),   // Extended queue
 } VkQueueFlagBits;
 
@@ -1401,7 +1401,7 @@
 {
     VkDeviceSize                                size;                       // Specified in bytes
     VkDeviceSize                                alignment;                  // Specified in bytes
-    VkDeviceSize                                granularity;                // Granularity on which vkQueueBindObjectMemoryRange can bind sub-ranges of memory specified in bytes (usually the page size)
+    VkDeviceSize                                granularity;                // Granularity at which memory can be bound to resource sub-ranges specified in bytes (usually the page size)
     VkMemoryPropertyFlags                       memPropsAllowed;            // Allowed memory property flags
     VkMemoryPropertyFlags                       memPropsRequired;           // Required memory property flags
 } VkMemoryRequirements;
@@ -2161,9 +2161,9 @@
 typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem);
 typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object);
 typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData);
-typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemory)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset);
-typedef VkResult (VKAPI *PFN_vkQueueBindObjectMemoryRange)(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkQueueBindImageMemoryRange)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkBindObjectMemory)(VkDevice device, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
 typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
 typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence* pFences);
 typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
@@ -2420,25 +2420,24 @@
 
 // Memory management API functions
 
-VkResult VKAPI vkQueueBindObjectMemory(
-    VkQueue                                     queue,
+VkResult VKAPI vkBindObjectMemory(
+    VkDevice                                    device,
     VkObjectType                                objType,
     VkObject                                    object,
     uint32_t                                    allocationIdx,
     VkDeviceMemory                              mem,
     VkDeviceSize                                memOffset);
 
-VkResult VKAPI vkQueueBindObjectMemoryRange(
+VkResult VKAPI vkQueueBindSparseBufferMemory(
     VkQueue                                     queue,
-    VkObjectType                                objType,
-    VkObject                                    object,
+    VkBuffer                                    buffer,
     uint32_t                                    allocationIdx,
     VkDeviceSize                                rangeOffset,
     VkDeviceSize                                rangeSize,
     VkDeviceMemory                              mem,
     VkDeviceSize                                memOffset);
 
-VkResult VKAPI vkQueueBindImageMemoryRange(
+VkResult VKAPI vkQueueBindSparseImageMemory(
     VkQueue                                     queue,
     VkImage                                     image,
     uint32_t                                    allocationIdx,
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 98b2df5..3d3a996 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1177,7 +1177,7 @@
             else {
                 char str[1024];
                 sprintf(str, "Destroying obj %p that is still bound to memory object %p\nYou should first clear binding "
-                             "by calling vkQueueBindObjectMemory(queue, %p, 0, VK_NULL_HANDLE, 0)",
+                             "by calling vkBindObjectMemory(queue, %p, 0, VK_NULL_HANDLE, 0)",
                              object, (void*)pDelInfo->pMemObjInfo->mem, object);
                 layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
                 // From the spec : If an object has previous memory binding, it is required to unbind memory
@@ -1203,22 +1203,22 @@
     void             *pData)
 {
     // TODO : What to track here?
-    //   Could potentially save returned mem requirements and validate values passed into QueueBindObjectMemory for this object
+    //   Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object
     // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues,
     //             command buffers, shaders and memory objects.
     VkResult result = nextTable.GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(
-    VkQueue        queue,
+VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(
+    VkDevice       device,
     VkObjectType   objType,
     VkObject       object,
     uint32_t       allocationIdx,
     VkDeviceMemory mem,
     VkDeviceSize   offset)
 {
-    VkResult result = nextTable.QueueBindObjectMemory(queue, objType, object, allocationIdx, mem, offset);
+    VkResult result = nextTable.BindObjectMemory(device, objType, object, allocationIdx, mem, offset);
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
     if (VK_FALSE == updateObjectBinding(object, mem)) {
@@ -1232,23 +1232,22 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(
+VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
     VkQueue        queue,
-    VkObjectType   objType,
-    VkObject       object,
+    VkBuffer       buffer,
     uint32_t       allocationIdx,
     VkDeviceSize   rangeOffset,
     VkDeviceSize   rangeSize,
     VkDeviceMemory mem,
     VkDeviceSize   memOffset)
 {
-    VkResult result = nextTable.QueueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+    VkResult result = nextTable.QueueBindSparseBufferMemory(queue, buffer, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
-    if (VK_FALSE == updateObjectBinding(object, mem)) {
+    if (VK_FALSE == updateObjectBinding(buffer, mem)) {
         char str[1024];
-        sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)object, (void*)mem);
-        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
+        sprintf(str, "Unable to set object %p binding to mem obj %p", (void*)buffer, (void*)mem);
+        layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, buffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     printObjList();
     printMemList();
@@ -2245,10 +2244,10 @@
         return (void*) vkDestroyObject;
     if (!strcmp(funcName, "vkGetObjectInfo"))
         return (void*) vkGetObjectInfo;
-    if (!strcmp(funcName, "vkQueueBindObjectMemory"))
-        return (void*) vkQueueBindObjectMemory;
-    if (!strcmp(funcName, "vkQueueBindObjectMemoryRange"))
-        return (void*) vkQueueBindObjectMemoryRange;
+    if (!strcmp(funcName, "vkBindObjectMemory"))
+        return (void*) vkBindObjectMemory;
+    if (!strcmp(funcName, "vkQueueBindSparseBufferMemory"))
+        return (void*) vkQueueBindSparseBufferMemory;
     if (!strcmp(funcName, "vkCreateFence"))
         return (void*) vkCreateFence;
     if (!strcmp(funcName, "vkGetFenceStatus"))
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 79783cb..e9e8bb9 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -516,32 +516,32 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
+VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
 {
 
-    VkResult result = nextTable.QueueBindObjectMemory(queue, objType, object, allocationIdx, mem, offset);
+    VkResult result = nextTable.BindObjectMemory(device, objType, object, allocationIdx, mem, offset);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
 {
 
-    VkResult result = nextTable.QueueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+    VkResult result = nextTable.QueueBindSparseBufferMemory(queue, buffer, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindImageMemoryRange(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
 {
     char str[1024];
     if (!pBindInfo) {
-        sprintf(str, "Struct ptr parameter pBindInfo to function QueueBindImageMemoryRange is NULL.");
+        sprintf(str, "Struct ptr parameter pBindInfo to function QueueBindSparseImageMemory is NULL.");
         layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
     else if (!vk_validate_vkimagememorybindinfo(pBindInfo)) {
         sprintf(str, "Parameter pBindInfo to function BindImageMemoryRange contains an invalid value.");
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
     }
-    VkResult result = nextTable.QueueBindImageMemoryRange(queue, image, allocationIdx, pBindInfo, mem, memOffset);
+    VkResult result = nextTable.QueueBindSparseImageMemory(queue, image, allocationIdx, pBindInfo, mem, memOffset);
     return result;
 }
 
diff --git a/loader/gpa_helper.h b/loader/gpa_helper.h
index 775b29c..28bb9e3 100644
--- a/loader/gpa_helper.h
+++ b/loader/gpa_helper.h
@@ -90,12 +90,12 @@
         return (void*) vkDestroyObject;
     if (!strcmp(name, "GetObjectInfo"))
         return (void*) vkGetObjectInfo;
-    if (!strcmp(name, "QueueBindObjectMemory"))
-        return (void*) vkQueueBindObjectMemory;
-    if (!strcmp(name, "QueueBindObjectMemoryRange"))
-        return (void*) vkQueueBindObjectMemoryRange;
-    if (!strcmp(name, "QueueBindImageMemoryRange"))
-        return (void*) vkQueueBindImageMemoryRange;
+    if (!strcmp(name, "BindObjectMemory"))
+        return (void*) vkBindObjectMemory;
+    if (!strcmp(name, "QueueBindSparseBufferMemory"))
+        return (void*) vkQueueBindSparseBufferMemory;
+    if (!strcmp(name, "QueueBindSparseImageMemory"))
+        return (void*) vkQueueBindSparseImageMemory;
     if (!strcmp(name, "CreateFence"))
         return (void*) vkCreateFence;
     if (!strcmp(name, "ResetFences"))
diff --git a/loader/table_ops.h b/loader/table_ops.h
index da2f7f1..1e2a99f 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -61,9 +61,9 @@
     table->OpenPeerImage = (PFN_vkOpenPeerImage) gpa(gpu, "vkOpenPeerImage");
     table->DestroyObject = (PFN_vkDestroyObject) gpa(gpu, "vkDestroyObject");
     table->GetObjectInfo = (PFN_vkGetObjectInfo) gpa(gpu, "vkGetObjectInfo");
-    table->QueueBindObjectMemory = (PFN_vkQueueBindObjectMemory) gpa(gpu, "vkQueueBindObjectMemory");
-    table->QueueBindObjectMemoryRange = (PFN_vkQueueBindObjectMemoryRange) gpa(gpu, "vkQueueBindObjectMemoryRange");
-    table->QueueBindImageMemoryRange = (PFN_vkQueueBindImageMemoryRange) gpa(gpu, "vkQueueBindImageMemoryRange");
+    table->BindObjectMemory = (PFN_vkBindObjectMemory) gpa(gpu, "vkBindObjectMemory");
+    table->QueueBindSparseBufferMemory = (PFN_vkQueueBindSparseBufferMemory) gpa(gpu, "vkQueueBindSparseBufferMemory");
+    table->QueueBindSparseImageMemory = (PFN_vkQueueBindSparseImageMemory) gpa(gpu, "vkQueueBindSparseImageMemory");
     table->CreateFence = (PFN_vkCreateFence) gpa(gpu, "vkCreateFence");
     table->ResetFences = (PFN_vkResetFences) gpa(gpu, "vkResetFences");
     table->GetFenceStatus = (PFN_vkGetFenceStatus) gpa(gpu, "vkGetFenceStatus");
@@ -226,12 +226,12 @@
         return (void *) table->DestroyObject;
     if (!strcmp(name, "GetObjectInfo"))
         return (void *) table->GetObjectInfo;
-    if (!strcmp(name, "QueueBindObjectMemory"))
-        return (void *) table->QueueBindObjectMemory;
-    if (!strcmp(name, "QueueBindObjectMemoryRange"))
-        return (void *) table->QueueBindObjectMemoryRange;
-    if (!strcmp(name, "QueueBindImageMemoryRange"))
-        return (void *) table->QueueBindImageMemoryRange;
+    if (!strcmp(name, "BindObjectMemory"))
+        return (void *) table->BindObjectMemory;
+    if (!strcmp(name, "QueueBindSparseBufferMemory"))
+        return (void *) table->QueueBindSparseBufferMemory;
+    if (!strcmp(name, "QueueBindSparseImageMemory"))
+        return (void *) table->QueueBindSparseImageMemory;
     if (!strcmp(name, "CreateFence"))
         return (void *) table->CreateFence;
     if (!strcmp(name, "ResetFences"))
diff --git a/loader/trampoline.c b/loader/trampoline.c
index d393c2b..f31bd64 100644
--- a/loader/trampoline.c
+++ b/loader/trampoline.c
@@ -254,31 +254,31 @@
     return disp->GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
+LOADER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
 {
     const VkLayerDispatchTable *disp;
 
-    disp = loader_get_dispatch(queue);
+    disp = loader_get_dispatch(device);
 
-    return disp->QueueBindObjectMemory(queue, objType, object, allocationIdx, mem, offset);
+    return disp->BindObjectMemory(device, objType, object, allocationIdx, mem, offset);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+    return disp->QueueBindSparseBufferMemory(queue, buffer, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
 }
 
-LOADER_EXPORT VkResult VKAPI vkQueueBindImageMemoryRange(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
 {
     const VkLayerDispatchTable *disp;
 
     disp = loader_get_dispatch(queue);
 
-    return disp->QueueBindImageMemoryRange(queue, image, allocationIdx, pBindInfo, mem, memOffset);
+    return disp->QueueBindSparseImageMemory(queue, image, allocationIdx, pBindInfo, mem, memOffset);
 }
 
 LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
diff --git a/loader/vulkan.def b/loader/vulkan.def
index d3bfe35..5749998 100644
--- a/loader/vulkan.def
+++ b/loader/vulkan.def
@@ -55,9 +55,9 @@
    vkOpenPeerImage
    vkDestroyObject
    vkGetObjectInfo
-   vkQueueBindObjectMemory
-   vkQueueBindObjectMemoryRange
-   vkQueueBindImageMemoryRange
+   vkBindObjectMemory
+   vkQueueBindSparseBufferMemory
+   vkQueueBindSparseImageMemory
    vkCreateFence
    vkResetFences
    vkGetFenceStatus
diff --git a/tests/blit_tests.cpp b/tests/blit_tests.cpp
index d754c05..bb3a667 100644
--- a/tests/blit_tests.cpp
+++ b/tests/blit_tests.cpp
@@ -775,7 +775,7 @@
     err = vkAllocMemory(dev_.obj(), &mem_info, &event_mem);
     ASSERT_VK_SUCCESS(err);
 
-    err = vkQueueBindObjectMemory(queue_.obj(), VK_OBJECT_TYPE_EVENT, event, 0, event_mem, 0);
+    err = vkBindObjectMemory(dev_.obj(), VK_OBJECT_TYPE_EVENT, event, 0, event_mem, 0);
     ASSERT_VK_SUCCESS(err);
 
     err = vkResetEvent(dev_.obj(), event);
@@ -832,7 +832,7 @@
     bufs[2].unmap();
 
     // All done with event memory, clean up
-    err = vkQueueBindObjectMemory(queue_.obj(), VK_OBJECT_TYPE_EVENT, event, 0, VK_NULL_HANDLE, 0);
+    err = vkBindObjectMemory(dev_.obj(), VK_OBJECT_TYPE_EVENT, event, 0, VK_NULL_HANDLE, 0);
     ASSERT_VK_SUCCESS(err);
 
     err = vkDestroyObject(dev_.obj(), VK_OBJECT_TYPE_EVENT, event);
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index fd2ccf5..8238edd 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -247,8 +247,7 @@
         ASSERT_VK_SUCCESS(err);
 
         /* bind memory */
-        VkQueue queue = m_device->graphics_queues()[0]->obj();
-        err = vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_IMAGE, m_image, i, m_image_mem[i], 0);
+        err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_image, i, m_image_mem[i], 0);
         ASSERT_VK_SUCCESS(err);
     }
 }
@@ -257,8 +256,7 @@
 {
     VkResult err;
     // All done with image memory, clean up
-    VkQueue queue = m_device->graphics_queues()[0]->obj();
-    ASSERT_VK_SUCCESS(vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_IMAGE, m_image, 0, VK_NULL_HANDLE, 0));
+    ASSERT_VK_SUCCESS(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_image, 0, VK_NULL_HANDLE, 0));
 
     for (uint32_t i = 0 ; i < m_num_mem; i++) {
         err = vkFreeMemory(device(), m_image_mem[i]);
diff --git a/tests/init.cpp b/tests/init.cpp
index 1932053..f9b5f31 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -261,7 +261,7 @@
     ASSERT_VK_SUCCESS(err);
 
     VkQueue queue = m_device->graphics_queues()[0]->obj();
-    err = vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_EVENT, event, 0, event_mem, 0);
+    err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, 0, event_mem, 0);
     ASSERT_VK_SUCCESS(err);
 
     err = vkResetEvent(device(), event);
@@ -279,7 +279,7 @@
     // TODO: Test actual synchronization with command buffer event.
 
     // All done with event memory, clean up
-    err = vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_EVENT, event, 0, VK_NULL_HANDLE, 0);
+    err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, 0, VK_NULL_HANDLE, 0);
     ASSERT_VK_SUCCESS(err);
 
     err = vkDestroyObject(device(), VK_OBJECT_TYPE_EVENT, event);
@@ -353,7 +353,7 @@
     ASSERT_VK_SUCCESS(err);
 
     VkQueue queue = m_device->graphics_queues()[0]->obj();
-    err = vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_QUERY_POOL, query_pool, 0, query_mem, 0);
+    err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, 0, query_mem, 0);
     ASSERT_VK_SUCCESS(err);
 
     // TODO: Test actual synchronization with command buffer event.
@@ -378,7 +378,7 @@
     }
 
     // All done with QueryPool memory, clean up
-    err = vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_QUERY_POOL, query_pool, 0, VK_NULL_HANDLE, 0);
+    err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, 0, VK_NULL_HANDLE, 0);
     ASSERT_VK_SUCCESS(err);
 
     err = vkDestroyObject(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool);
@@ -433,7 +433,7 @@
 //                    VK_QUEUE_GRAPHICS_BIT                                  = 0x00000001,   // Queue supports graphics operations
 //                    VK_QUEUE_COMPUTE_BIT                                   = 0x00000002,   // Queue supports compute operations
 //                    VK_QUEUE_DMA_BIT                                       = 0x00000004,   // Queue supports DMA operations
-//                    VK_QUEUE_MEMMGR_BIT                                    = 0x00000008,   // Queue supports MEMMGR operations
+//                    VK_QUEUE_SPARSE_MEMMGR_BIT                             = 0x00000008,   // Queue supports sparse resource memory management operations
 //                    VK_QUEUE_EXTENDED_BIT                                  = 0x80000000    // Extended queue
 //                } VkQueueFlags;
 
@@ -621,7 +621,7 @@
     ASSERT_VK_SUCCESS(err);
 
     VkQueue queue = m_device->graphics_queues()[0]->obj();
-    err = vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_IMAGE, image, 0, image_mem, 0);
+    err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, 0, image_mem, 0);
     ASSERT_VK_SUCCESS(err);
 
 //    typedef struct VkImageViewCreateInfo_
@@ -664,7 +664,7 @@
     // TODO: Test image memory.
 
     // All done with image memory, clean up
-    ASSERT_VK_SUCCESS(vkQueueBindObjectMemory(queue, VK_OBJECT_TYPE_IMAGE, image, 0, VK_NULL_HANDLE, 0));
+    ASSERT_VK_SUCCESS(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, 0, VK_NULL_HANDLE, 0));
 
     ASSERT_VK_SUCCESS(vkFreeMemory(device(), image_mem));
 
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 753fe53..9def17d 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -106,7 +106,7 @@
     }
     while (!m_renderTargets.empty()) {
         vkDestroyObject(device(), VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, m_renderTargets.back()->targetView());
-        vkQueueBindObjectMemory(m_device->m_queue, VK_OBJECT_TYPE_IMAGE, m_renderTargets.back()->image(), 0, VK_NULL_HANDLE, 0);
+        vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_renderTargets.back()->image(), 0, VK_NULL_HANDLE, 0);
         vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE, m_renderTargets.back()->image());
         vkFreeMemory(device(), m_renderTargets.back()->memory());
         m_renderTargets.pop_back();
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 4106bb3..0870f84 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -255,21 +255,13 @@
 {
     bound = true;
     VkQueue queue = dev_->graphics_queues()[0]->obj();
-    EXPECT(vkQueueBindObjectMemory(queue, type(), obj(), alloc_idx, mem.obj(), mem_offset) == VK_SUCCESS);
-}
-
-void Object::bind_memory(uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
-                         const GpuMemory &mem, VkDeviceSize mem_offset)
-{
-    bound = true;
-    VkQueue queue = dev_->graphics_queues()[0]->obj();
-    EXPECT(!alloc_idx && vkQueueBindObjectMemoryRange(queue, type(), obj(), 0, offset, size, mem.obj(), mem_offset) == VK_SUCCESS);
+    EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), alloc_idx, mem.obj(), mem_offset) == VK_SUCCESS);
 }
 
 void Object::unbind_memory(uint32_t alloc_idx)
 {
     VkQueue queue = dev_->graphics_queues()[0]->obj();
-    EXPECT(vkQueueBindObjectMemory(queue, type(), obj(), alloc_idx, VK_NULL_HANDLE, 0) == VK_SUCCESS);
+    EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), alloc_idx, VK_NULL_HANDLE, 0) == VK_SUCCESS);
 }
 
 void Object::unbind_memory()
@@ -675,6 +667,13 @@
     create_info_ = info;
 }
 
+void Buffer::bind_memory(uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
+                         const GpuMemory &mem, VkDeviceSize mem_offset)
+{
+    VkQueue queue = dev_->graphics_queues()[0]->obj();
+    EXPECT(!alloc_idx && vkQueueBindSparseBufferMemory(queue, obj(), 0, offset, size, mem.obj(), mem_offset) == VK_SUCCESS);
+}
+
 void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
 {
     DERIVED_OBJECT_TYPE_INIT(vkCreateBufferView, dev, VK_OBJECT_TYPE_BUFFER_VIEW, &info);
@@ -727,7 +726,7 @@
                         const GpuMemory &mem, VkDeviceSize mem_offset)
 {
     VkQueue queue = dev.graphics_queues()[0]->obj();
-    EXPECT(!alloc_idx && vkQueueBindImageMemoryRange(queue, obj(), 0, &info, mem.obj(), mem_offset) == VK_SUCCESS);
+    EXPECT(!alloc_idx && vkQueueBindSparseImageMemory(queue, obj(), 0, &info, mem.obj(), mem_offset) == VK_SUCCESS);
 }
 
 VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 78896ae..e25894b 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -130,15 +130,11 @@
     uint32_t memory_allocation_count() const;
     std::vector<VkMemoryRequirements> memory_requirements() const;
 
-    // vkQueueBindObjectMemory()
+    // vkBindObjectMemory()
     void bind_memory(uint32_t alloc_idx, const GpuMemory &mem, VkDeviceSize mem_offset);
     void unbind_memory(uint32_t alloc_idx);
     void unbind_memory();
 
-    // vkQueueBindObjectMemoryRange()
-    void bind_memory(uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
-                     const GpuMemory &mem, VkDeviceSize mem_offset);
-
     // Unless an object is initialized with init_no_mem(), memories are
     // automatically allocated and bound.  These methods can be used to
     // map/unmap the primary memory.
@@ -382,6 +378,10 @@
     void init(const Device &dev, const VkBufferCreateInfo &info, VkMemoryPropertyFlags &reqs);
     void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
 
+    // vkQueueBindSparseBufferMemory()
+    void bind_memory(uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
+                     const GpuMemory &mem, VkDeviceSize mem_offset);
+
     static VkBufferCreateInfo create_info(VkDeviceSize size, VkFlags usage);
 
     VkBufferMemoryBarrier buffer_memory_barrier(VkFlags output_mask, VkFlags input_mask,
@@ -418,7 +418,7 @@
     // vkOpenPeerImage()
     void init(const Device &dev, const VkPeerImageOpenInfo &info, const VkImageCreateInfo &original_info);
 
-    // vkQueueBindImageMemoryRange()
+    // vkQueueBindSparseImageMemory()
     void bind_memory(const Device &dev, uint32_t alloc_idx, const VkImageMemoryBindInfo &info,
                      const GpuMemory &mem, VkDeviceSize mem_offset);
 
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 0d375c7..cc30a22 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -1115,11 +1115,11 @@
         header_txt.append('    }')
         header_txt.append('    if (pQueueInfo != NULL) {')
         header_txt.append('        char str[1024];\n')
-        header_txt.append('        if ((queueInfo != NULL) && (queueInfo[pQueueInfo->queueNodeIndex].queueFlags & VK_QUEUE_MEMMGR_BIT) == 0) {')
-        header_txt.append('            sprintf(str, "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_MEMMGR_BIT not set", function);')
+        header_txt.append('        if ((queueInfo != NULL) && (queueInfo[pQueueInfo->queueNodeIndex].queueFlags & VK_QUEUE_SPARSE_MEMMGR_BIT) == 0) {')
+        header_txt.append('            sprintf(str, "Attempting %s on a non-memory-management capable queue -- VK_QUEUE_SPARSE_MEMMGR_BIT not set", function);')
         header_txt.append('            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
         header_txt.append('        } else {')
-        header_txt.append('            sprintf(str, "Attempting %s on a possibly non-memory-management capable queue -- VK_QUEUE_MEMMGR_BIT not known", function);')
+        header_txt.append('            sprintf(str, "Attempting %s on a possibly non-memory-management capable queue -- VK_QUEUE_SPARSE_MEMMGR_BIT not known", function);')
         header_txt.append('            layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, OBJTRACK_UNKNOWN_OBJECT, "OBJTRACK", str);')
         header_txt.append('        }')
         header_txt.append('    }')
@@ -1184,19 +1184,14 @@
             using_line += '    // validate_memory_mapping_status(pMemRefs, memRefCount);\n'
             using_line += '    // validate_mem_ref_count(memRefCount);\n'
             using_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
-        elif 'QueueBindObjectMemoryRange' in proto.name:
+        elif 'QueueBindSparse' in proto.name:
             using_line  = '    loader_platform_thread_lock_mutex(&objLock);\n'
-            using_line += '    validateObjectType("vk%s", objType, object);\n' % (proto.name)
             using_line += '    validateQueueFlags(queue, "%s");\n' % (proto.name)
             using_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         elif 'QueueBindObject' in proto.name:
             using_line  = '    loader_platform_thread_lock_mutex(&objLock);\n'
             using_line += '    validateObjectType("vk%s", objType, object);\n' % (proto.name)
             using_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
-        elif 'QueueBindImage' in proto.name:
-            using_line  = '    loader_platform_thread_lock_mutex(&objLock);\n'
-            using_line += '    validateQueueFlags(queue, "%s");\n' % (proto.name)
-            using_line += '    loader_platform_thread_unlock_mutex(&objLock);\n'
         elif 'GetObjectInfo' in proto.name:
             using_line  = '    loader_platform_thread_lock_mutex(&objLock);\n'
             using_line += '    validateObjectType("vk%s", objType, object);\n' % (proto.name)
diff --git a/vulkan.py b/vulkan.py
index 9030ea4..e2a6905 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -370,25 +370,24 @@
              Param("size_t*", "pDataSize"),
              Param("void*", "pData")]),
 
-        Proto("VkResult", "QueueBindObjectMemory",
-            [Param("VkQueue", "queue"),
+        Proto("VkResult", "BindObjectMemory",
+            [Param("VkDevice", "device"),
              Param("VkObjectType", "objType"), 
              Param("VkObject", "object"),
              Param("uint32_t", "allocationIdx"),
              Param("VkDeviceMemory", "mem"),
              Param("VkDeviceSize", "offset")]),
 
-        Proto("VkResult", "QueueBindObjectMemoryRange",
+        Proto("VkResult", "QueueBindSparseBufferMemory",
             [Param("VkQueue", "queue"),
-             Param("VkObjectType", "objType"), 
-             Param("VkObject", "object"),
+             Param("VkBuffer", "buffer"),
              Param("uint32_t", "allocationIdx"),
              Param("VkDeviceSize", "rangeOffset"),
              Param("VkDeviceSize", "rangeSize"),
              Param("VkDeviceMemory", "mem"),
              Param("VkDeviceSize", "memOffset")]),
 
-        Proto("VkResult", "QueueBindImageMemoryRange",
+        Proto("VkResult", "QueueBindSparseImageMemory",
             [Param("VkQueue", "queue"),
              Param("VkImage", "image"),
              Param("uint32_t", "allocationIdx"),