diff --git a/include/vkLayer.h b/include/vkLayer.h
index 813e687..53460c7 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -39,8 +39,8 @@
     PFN_vkEnumerateLayers EnumerateLayers;
     PFN_vkGetDeviceQueue GetDeviceQueue;
     PFN_vkQueueSubmit QueueSubmit;
-    PFN_vkQueueAddMemReference QueueAddMemReference;
-    PFN_vkQueueRemoveMemReference QueueRemoveMemReference;
+    PFN_vkQueueAddMemReferences QueueAddMemReferences;
+    PFN_vkQueueRemoveMemReferences QueueRemoveMemReferences;
     PFN_vkQueueWaitIdle QueueWaitIdle;
     PFN_vkDeviceWaitIdle DeviceWaitIdle;
     PFN_vkAllocMemory AllocMemory;
@@ -108,7 +108,7 @@
     PFN_vkCmdBindPipeline CmdBindPipeline;
     PFN_vkCmdBindDynamicStateObject CmdBindDynamicStateObject;
     PFN_vkCmdBindDescriptorSets CmdBindDescriptorSets;
-    PFN_vkCmdBindVertexBuffer CmdBindVertexBuffer;
+    PFN_vkCmdBindVertexBuffers CmdBindVertexBuffers;
     PFN_vkCmdBindIndexBuffer CmdBindIndexBuffer;
     PFN_vkCmdDraw CmdDraw;
     PFN_vkCmdDrawIndexed CmdDrawIndexed;
diff --git a/include/vulkan.h b/include/vulkan.h
index 77b7010..0edbfcf 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -2210,8 +2210,8 @@
 typedef VkResult (VKAPI *PFN_vkEnumerateLayers)(VkPhysicalGpu gpu, size_t maxLayerCount, size_t maxStringSize, size_t* pOutLayerCount, char* const* pOutLayers, void* pReserved);
 typedef VkResult (VKAPI *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue);
 typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence);
-typedef VkResult (VKAPI *PFN_vkQueueAddMemReference)(VkQueue queue, VkGpuMemory mem);
-typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReference)(VkQueue queue, VkGpuMemory mem);
+typedef VkResult (VKAPI *PFN_vkQueueAddMemReferences)(VkQueue queue, uint32_t count, const VkGpuMemory* pMems);
+typedef VkResult (VKAPI *PFN_vkQueueRemoveMemReferences)(VkQueue queue, uint32_t count, const VkGpuMemory* pMems);
 typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
 typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
 typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkGpuMemory* pMem);
@@ -2280,7 +2280,7 @@
 typedef void     (VKAPI *PFN_vkCmdBindDynamicStateObject)(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state);
 typedef void     (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkDescriptorSetLayoutChain layoutChain, uint32_t layoutChainSlot, uint32_t count, const VkDescriptorSet* pDescriptorSets, const uint32_t* pUserData);
 typedef void     (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType);
-typedef void     (VKAPI *PFN_vkCmdBindVertexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding);
+typedef void     (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkGpuSize* pOffsets);
 typedef void     (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount);
 typedef void     (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount);
 typedef void     (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t count, uint32_t stride);
@@ -2390,13 +2390,15 @@
     const VkCmdBuffer*                          pCmdBuffers,
     VkFence                                     fence);
 
-VkResult VKAPI vkQueueAddMemReference(
+VkResult VKAPI vkQueueAddMemReferences(
     VkQueue                                     queue,
-    VkGpuMemory                                 mem);
+    uint32_t                                    count,
+    const VkGpuMemory*                          pMems);
 
-VkResult VKAPI vkQueueRemoveMemReference(
+VkResult VKAPI vkQueueRemoveMemReferences(
     VkQueue                                     queue,
-    VkGpuMemory                                 mem);
+    uint32_t                                    count,
+    const VkGpuMemory*                          pMems);
 
 VkResult VKAPI vkQueueWaitIdle(
     VkQueue                                     queue);
@@ -2783,11 +2785,12 @@
     VkGpuSize                                   offset,
     VkIndexType                                 indexType);
 
-void VKAPI vkCmdBindVertexBuffer(
+void VKAPI vkCmdBindVertexBuffers(
     VkCmdBuffer                                 cmdBuffer,
-    VkBuffer                                    buffer,
-    VkGpuSize                                   offset,
-    uint32_t                                    binding);
+    uint32_t                                    startBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkGpuSize*                            pOffsets);
 
 void VKAPI vkCmdDraw(
     VkCmdBuffer                                 cmdBuffer,
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 5dbf962..01e4e55 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2053,21 +2053,26 @@
     nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
+    VkCmdBuffer                                 cmdBuffer,
+    uint32_t                                    startBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkGpuSize*                            pOffsets)
 {
     GLOBAL_CB_NODE* pCB = getCBNode(cmdBuffer);
     if (pCB) {
+        /* TODO: Need to track all the vertex buffers, not just last one */
         updateCBTracking(cmdBuffer);
         addCmd(pCB, CMD_BINDVERTEXBUFFER);
-        pCB->lastVtxBinding = binding;
+        pCB->lastVtxBinding = startBinding + bindingCount -1;
         validateVBBinding(cmdBuffer);
-    }
-    else {
+    } else {
         char str[1024];
         sprintf(str, "Attempt to use CmdBuffer %p that doesn't exist!", (void*)cmdBuffer);
         layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, cmdBuffer, 0, DRAWSTATE_INVALID_CMD_BUFFER, "DS", str);
     }
-    nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
+    nextTable.CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
@@ -2792,8 +2797,8 @@
         return (void*) vkCmdBindDynamicStateObject;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
         return (void*) vkCmdBindDescriptorSets;
-    if (!strcmp(funcName, "vkCmdBindVertexBuffer"))
-        return (void*) vkCmdBindVertexBuffer;
+    if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
+        return (void*) vkCmdBindVertexBuffers;
     if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
         return (void*) vkCmdBindIndexBuffer;
     if (!strcmp(funcName, "vkCmdDraw"))
diff --git a/layers/glave_snapshot.c b/layers/glave_snapshot.c
index 0554d97..3192a77 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -1305,12 +1305,17 @@
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
+    VkCmdBuffer                                 cmdBuffer,
+    uint32_t                                    startBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers
+    const VkGpuSize*                            pOffsets)
 {
     loader_platform_thread_lock_mutex(&objLock);
     ll_increment_use_count((void*)cmdBuffer, VK_OBJECT_TYPE_CMD_BUFFER);
     loader_platform_thread_unlock_mutex(&objLock);
-    nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
+    nextTable.CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType)
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 684cb22..5067578 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -975,9 +975,9 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory mem)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReferences(VkQueue queue, uint32_t count, const VkGpuMemory* pMems)
 {
-    VkResult result = nextTable.QueueAddMemReference(queue, mem);
+    VkResult result = nextTable.QueueAddMemReferences(queue, count, pMems);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
 
@@ -986,17 +986,17 @@
             char str[1024];
             sprintf(str, "Unknown Queue %p", queue);
             layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
-        }
-        else {
-            if (checkMemRef(queue, mem) == VK_TRUE) {
-                // Alread in list, just warn
-                char str[1024];
-                sprintf(str, "Request to add a memory reference (%p) to Queue %p -- ref is already present in the queue's reference list", mem, queue);
-                layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, mem, 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
-            }
-            else {
-                // Add to queue's memory reference list
-                pQueueInfo->pMemRefList.push_front(mem);
+        } else {
+            for (int i = 0; i < count; i++) {
+                if (checkMemRef(queue, pMems[i]) == VK_TRUE) {
+                    // Alread in list, just warn
+                    char str[1024];
+                    sprintf(str, "Request to add a memory reference (%p) to Queue %p -- ref is already present in the queue's reference list", pMems[i], queue);
+                    layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, pMems[i], 0, MEMTRACK_INVALID_MEM_REF, "MEM", str);
+                } else {
+                    // Add to queue's memory reference list
+                    pQueueInfo->pMemRefList.push_front(pMems[i]);
+                }
             }
         }
         loader_platform_thread_unlock_mutex(&globalLock);
@@ -1004,10 +1004,10 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReference(VkQueue queue, VkGpuMemory mem)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReferences(VkQueue queue, uint32_t count, const VkGpuMemory* pMems)
 {
     // TODO : Decrement ref count for this memory reference on this queue. Remove if ref count is zero.
-    VkResult result = nextTable.QueueRemoveMemReference(queue, mem);
+    VkResult result = nextTable.QueueRemoveMemReferences(queue, count, pMems);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
 
@@ -1016,11 +1016,12 @@
             char str[1024];
             sprintf(str, "Unknown Queue %p", queue);
             layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, queue, 0, MEMTRACK_INVALID_QUEUE, "MEM", str);
-        }
-        else {
-            for (list<VkGpuMemory>::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
-                if ((*it) == mem) {
-                    it = pQueueInfo->pMemRefList.erase(it);
+        } else {
+            for (int i = 0; i < count; i++) {
+                for (list<VkGpuMemory>::iterator it = pQueueInfo->pMemRefList.begin(); it != pQueueInfo->pMemRefList.end(); ++it) {
+                    if ((*it) == pMems[i]) {
+                        it = pQueueInfo->pMemRefList.erase(it);
+                    }
                 }
             }
         }
@@ -1615,9 +1616,14 @@
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
+    VkCmdBuffer                                 cmdBuffer,
+    uint32_t                                    startBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkGpuSize*                            pOffsets)
 {
-    nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
+    nextTable.CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType)
@@ -2074,8 +2080,8 @@
         return (void*) vkCmdBindDynamicStateObject;
     if (!strcmp(funcName, "vkCmdBindDescriptorSets"))
         return (void*) vkCmdBindDescriptorSets;
-    if (!strcmp(funcName, "vkCmdBindVertexBuffer"))
-        return (void*) vkCmdBindVertexBuffer;
+    if (!strcmp(funcName, "vkCmdBindVertexBuffers"))
+        return (void*) vkCmdBindVertexBuffers;
     if (!strcmp(funcName, "vkCmdBindIndexBuffer"))
         return (void*) vkCmdBindIndexBuffer;
     if (!strcmp(funcName, "vkCmdDrawIndirect"))
@@ -2116,10 +2122,10 @@
         return (void*) vkDbgUnregisterMsgCallback;
     if (!strcmp(funcName, "vkGetDeviceQueue"))
         return (void*) vkGetDeviceQueue;
-    if (!strcmp(funcName, "vkQueueAddMemReference"))
-        return (void*) vkQueueAddMemReference;
-    if (!strcmp(funcName, "vkQueueRemoveMemReference"))
-        return (void*) vkQueueRemoveMemReference;
+    if (!strcmp(funcName, "vkQueueAddMemReferences"))
+        return (void*) vkQueueAddMemReferences;
+    if (!strcmp(funcName, "vkQueueRemoveMemReferences"))
+        return (void*) vkQueueRemoveMemReferences;
 #if !defined(WIN32)
     if (!strcmp(funcName, "vkWsiX11CreatePresentableImage"))
         return (void*) vkWsiX11CreatePresentableImage;
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 77040ef..f856283 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -340,15 +340,15 @@
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory mem)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReferences(VkQueue queue, uint32_t count, const VkGpuMemory* pMems)
 {
-    VkResult result = nextTable.QueueAddMemReference(queue, mem);
+    VkResult result = nextTable.QueueAddMemReferences(queue, count, pMems);
     return result;
 }
 
-VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReference(VkQueue queue, VkGpuMemory mem)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReferences(VkQueue queue, uint32_t count, const VkGpuMemory* pMems)
 {
-    VkResult result = nextTable.QueueRemoveMemReference(queue, mem);
+    VkResult result = nextTable.QueueRemoveMemReferences(queue, count, pMems);
     return result;
 }
 VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue)
@@ -1221,10 +1221,14 @@
     nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layoutChain, layoutChainSlot, count, pDescriptorSets, pUserData);
 }
 
-VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, uint32_t binding)
+VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
+    VkCmdBuffer                                 cmdBuffer,
+    uint32_t                                    startBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkGpuSize*                            pOffsets)
 {
-
-    nextTable.CmdBindVertexBuffer(cmdBuffer, buffer, offset, binding);
+    nextTable.CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkGpuSize offset, VkIndexType indexType)
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 7e5aa68..42ed4fe 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -774,7 +774,7 @@
 
 void VkConstantBufferObj::Bind(VkCmdBuffer cmdBuffer, VkGpuSize offset, uint32_t binding)
 {
-    vkCmdBindVertexBuffer(cmdBuffer, obj(), offset, binding);
+    vkCmdBindVertexBuffers(cmdBuffer, binding, 1, &obj(), &offset);
 }
 
 
@@ -1135,16 +1135,12 @@
 
 void VkMemoryRefManager::EmitAddMemoryRefs(VkQueue queue)
 {
-    for (uint32_t i = 0; i < mem_refs_.size(); i++) {
-        vkQueueAddMemReference(queue, mem_refs_[i]);
-    }
+    vkQueueAddMemReferences(queue, mem_refs_.size(), &mem_refs_[0]);
 }
 
 void VkMemoryRefManager::EmitRemoveMemoryRefs(VkQueue queue)
 {
-    for (uint32_t i = 0; i < mem_refs_.size(); i++) {
-        vkQueueRemoveMemReference(queue, mem_refs_[i]);
-    }
+    vkQueueRemoveMemReferences(queue, mem_refs_.size(), &mem_refs_[0]);
 }
 
 VkCommandBufferObj::VkCommandBufferObj(VkDeviceObj *device)
@@ -1411,9 +1407,9 @@
     mem_ref_mgr.AddMemoryRefs(*indexBuffer);
 }
 
-void VkCommandBufferObj::BindVertexBuffer(VkConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding)
+void VkCommandBufferObj::BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkGpuSize offset, uint32_t binding)
 {
-    vkCmdBindVertexBuffer(obj(), vertexBuffer->obj(), offset, binding);
+    vkCmdBindVertexBuffers(obj(), binding, 1, &vertexBuffer->obj(), &offset);
     mem_ref_mgr.AddMemoryRefs(*vertexBuffer);
 }
 
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 7cb3e17..0c2777b 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -167,7 +167,7 @@
     void AddMemoryRefs(vector<vk_testing::Object *> images);
     void BindPipeline(VkPipelineObj &pipeline);
     void BindDescriptorSet(VkDescriptorSetObj &descriptorSet);
-    void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, uint32_t offset, uint32_t binding);
+    void BindVertexBuffer(VkConstantBufferObj *vertexBuffer, VkGpuSize offset, uint32_t binding);
     void BindIndexBuffer(VkIndexBufferObj *indexBuffer, uint32_t offset);
     void BindStateObject(VkStateBindPoint stateBindPoint, VkDynamicStateObject stateObject);
     void BeginRenderPass(VkRenderPass renderpass, VkFramebuffer framebuffer);
diff --git a/tests/vktestbinding.cpp b/tests/vktestbinding.cpp
index 1287e7a..d9cdc9b 100644
--- a/tests/vktestbinding.cpp
+++ b/tests/vktestbinding.cpp
@@ -499,16 +499,12 @@
 
 void Queue::add_mem_references(const std::vector<VkGpuMemory> &mem_refs)
 {
-    for (int i = 0; i < mem_refs.size(); i++) {
-        EXPECT(vkQueueAddMemReference(obj(), mem_refs[i]) == VK_SUCCESS);
-    }
+    EXPECT(vkQueueAddMemReferences(obj(), mem_refs.size(), &mem_refs[0]) == VK_SUCCESS);
 }
 
 void Queue::remove_mem_references(const std::vector<VkGpuMemory> &mem_refs)
 {
-    for (int i = 0; i < mem_refs.size(); i++) {
-        EXPECT(vkQueueRemoveMemReference(obj(), mem_refs[i]) == VK_SUCCESS);
-    }
+    EXPECT(vkQueueRemoveMemReferences(obj(), mem_refs.size(), &mem_refs[0]) == VK_SUCCESS);
 }
 
 void Queue::wait()
diff --git a/tests/vktestbinding.h b/tests/vktestbinding.h
index 75bc433..18de306 100644
--- a/tests/vktestbinding.h
+++ b/tests/vktestbinding.h
@@ -137,7 +137,7 @@
 
     // Unless an object is initialized with init_no_mem(), memories are
     // automatically allocated and bound.  These methods can be used to get
-    // the memories (for vkQueueAddMemReference), or to map/unmap the primary memory.
+    // the memories (for vkQueueAddMemReferences), or to map/unmap the primary memory.
     std::vector<VkGpuMemory> memories() const;
 
     const void *map(VkFlags flags) const;
@@ -259,8 +259,8 @@
     void submit(const CmdBuffer &cmd, Fence &fence);
     void submit(const CmdBuffer &cmd);
 
-    // vkQueueAddMemReference()
-    // vkQueueRemoveMemReference()
+    // vkQueueAddMemReferences()
+    // vkQueueRemoveMemReferences()
     void add_mem_references(const std::vector<VkGpuMemory> &mem_refs);
     void remove_mem_references(const std::vector<VkGpuMemory> &mem_refs);
 
diff --git a/tests/vktestframework.cpp b/tests/vktestframework.cpp
index 1912bb7..de59fd4 100644
--- a/tests/vktestframework.cpp
+++ b/tests/vktestframework.cpp
@@ -523,8 +523,8 @@
                 1, &region);
         m_cmdbuf.end();
 
-        vkQueueAddMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
-        vkQueueAddMemReference(m_queue.obj(), buf.memories()[0]);
+        vkQueueAddMemReferences(m_queue.obj(), 1, &m_display_image->m_presentableMemory);
+        vkQueueAddMemReferences(m_queue.obj(), buf.memories().size(), &buf.memories()[0]);
 
         VkCmdBuffer cmdBufs[1];
         cmdBufs[0] = m_cmdbuf.obj();
@@ -532,8 +532,8 @@
         vkQueueSubmit(m_queue.obj(), 1, cmdBufs, NULL);
         m_queue.wait();
 
-        vkQueueRemoveMemReference(m_queue.obj(), m_display_image->m_presentableMemory);
-        vkQueueRemoveMemReference(m_queue.obj(), buf.memories()[0]);
+        vkQueueRemoveMemReferences(m_queue.obj(), 1, &m_display_image->m_presentableMemory);
+        vkQueueRemoveMemReferences(m_queue.obj(), buf.memories().size(), &buf.memories()[0]);
 
         if (m_display_image->m_width > m_width)
             m_width = m_display_image->m_width;
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index a74b4eb..cb429aa 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -1103,7 +1103,7 @@
         destroy_line = ''
         funcs = []
         # Special cases for API funcs that don't use an object as first arg
-        if True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueAddMemReference', 'QueueRemoveMemReference', 'QueueWaitIdle', 'GetGlobalExtensionInfo', 'CreateDevice', 'GetGpuInfo', 'QueueSignalSemaphore', 'QueueWaitSemaphore', 'WsiX11QueuePresent']]:
+        if True in [no_use_proto in proto.name for no_use_proto in ['GlobalOption', 'CreateInstance', 'QueueSubmit', 'QueueAddMemReferences', 'QueueRemoveMemReferences', 'QueueWaitIdle', 'GetGlobalExtensionInfo', 'CreateDevice', 'GetGpuInfo', 'QueueSignalSemaphore', 'QueueWaitSemaphore', 'WsiX11QueuePresent']]:
             using_line = ''
         else:
             using_line = '    loader_platform_thread_lock_mutex(&objLock);\n'
diff --git a/vulkan.py b/vulkan.py
index 6d5bd58..56b95c2 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -282,13 +282,15 @@
              Param("const VkCmdBuffer*", "pCmdBuffers"),
              Param("VkFence", "fence")]),
 
-        Proto("VkResult", "QueueAddMemReference",
+        Proto("VkResult", "QueueAddMemReferences",
             [Param("VkQueue", "queue"),
-             Param("VkGpuMemory", "mem")]),
+             Param("uint32_t", "count"),
+             Param("const VkGpuMemory*", "pMems")]),
 
-        Proto("VkResult", "QueueRemoveMemReference",
+        Proto("VkResult", "QueueRemoveMemReferences",
             [Param("VkQueue", "queue"),
-             Param("VkGpuMemory", "mem")]),
+             Param("uint32_t", "count"),
+             Param("const VkGpuMemory*", "pMems")]),
 
         Proto("VkResult", "QueueWaitIdle",
             [Param("VkQueue", "queue")]),
@@ -629,11 +631,12 @@
              Param("const VkDescriptorSet*", "pDescriptorSets"),
              Param("const uint32_t*", "pUserData")]),
 
-        Proto("void", "CmdBindVertexBuffer",
+        Proto("void", "CmdBindVertexBuffers",
             [Param("VkCmdBuffer", "cmdBuffer"),
-             Param("VkBuffer", "buffer"),
-             Param("VkGpuSize", "offset"),
-             Param("uint32_t", "binding")]),
+             Param("uint32_t", "startBinding"),
+             Param("uint32_t", "bindingCount"),
+             Param("const VkBuffer*", "pBuffers"),
+             Param("const VkGpuSize*", "pOffsets")]),
 
         Proto("void", "CmdBindIndexBuffer",
             [Param("VkCmdBuffer", "cmdBuffer"),