bug 13632: Convert commands to plural form

part of multiple commits to implement bug #13632.
bug 13632
header version 82
svn version: 30446

This patch converts:
vkCmdBindVertexBuffer -> vkCmdBindVertexBuffers
vkQueueAddMemReference -> vkQueueAddMemReferences
vkQueueRemoveMemReference -> vkQueueRemoveMemReferences

11 files changed, 113 insertions, 92 deletions

diff --git a/demos/cube.c b/demos/cube.c
index 13fc1dbd..13d2ff08 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -296,18 +296,14 @@ static void demo_add_mem_refs(
         struct demo *demo,
         int num_refs, VkGpuMemory *mem)
 {
-    for (int i = 0; i < num_refs; i++) {
-        vkQueueAddMemReference(demo->queue, mem[i]);
-    }
+    vkQueueAddMemReferences(demo->queue, num_refs, mem);
 }
 
 static void demo_remove_mem_refs(
         struct demo *demo,
         int num_refs, VkGpuMemory *mem)
 {
-    for (int i = 0; i < num_refs; i++) {
-        vkQueueRemoveMemReference(demo->queue, mem[i]);
-    }
+    vkQueueRemoveMemReferences(demo->queue, num_refs, mem);
 }
 
 static void demo_set_image_layout(
diff --git a/demos/tri.c b/demos/tri.c
index 299d36b4..8918a2c3 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -125,18 +125,14 @@ static void demo_add_mem_refs(
         struct demo *demo,
         int num_refs, VkGpuMemory *mem)
 {
-    for (int i = 0; i < num_refs; i++) {
-        vkQueueAddMemReference(demo->queue, mem[i]);
-    }
+    vkQueueAddMemReferences(demo->queue, num_refs, mem);
 }
 
 static void demo_remove_mem_refs(
         struct demo *demo,
         int num_refs, VkGpuMemory *mem)
 {
-    for (int i = 0; i < num_refs; i++) {
-        vkQueueRemoveMemReference(demo->queue, mem[i]);
-    }
+    vkQueueRemoveMemReferences(demo->queue, num_refs, mem);
 }
 
 static void demo_set_image_layout(
@@ -281,8 +277,8 @@ static void demo_draw_build_cmd(struct demo *demo)
     vkCmdBindDynamicStateObject(demo->cmd, VK_STATE_BIND_DEPTH_STENCIL,
                                      demo->depth_stencil);
 
-
-    vkCmdBindVertexBuffer(demo->cmd, demo->vertices.buf, 0, VERTEX_BUFFER_BIND_ID);
+    VkGpuSize offsets[1] = {0};
+    vkCmdBindVertexBuffers(demo->cmd, VERTEX_BUFFER_BIND_ID, 1, &demo->vertices.buf, offsets);
 
     vkCmdBeginRenderPass(demo->cmd, &rp_begin);
     clear_range.aspect = VK_IMAGE_ASPECT_COLOR;
diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c
index 1d36ff6f..6d1ed15c 100644
--- a/icd/nulldrv/nulldrv.c
+++ b/icd/nulldrv/nulldrv.c
@@ -1056,11 +1056,12 @@ ICD_EXPORT void VKAPI vkCmdBindDescriptorSets(
     NULLDRV_LOG_FUNC;
 }
 
-ICD_EXPORT void VKAPI vkCmdBindVertexBuffer(
-    VkCmdBuffer                              cmdBuffer,
-    VkBuffer                                  buffer,
-    VkGpuSize                                offset,
-    uint32_t                                    binding)
+ICD_EXPORT void VKAPI vkCmdBindVertexBuffers(
+    VkCmdBuffer                                 cmdBuffer,
+    uint32_t                                    startBinding,
+    uint32_t                                    bindingCount,
+    const VkBuffer*                             pBuffers,
+    const VkGpuSize*                            pOffsets)
 {
     NULLDRV_LOG_FUNC;
 }
@@ -1732,17 +1733,19 @@ ICD_EXPORT VkResult VKAPI vkGetQueryPoolResults(
     return VK_SUCCESS;
 }
 
-ICD_EXPORT VkResult VKAPI vkQueueAddMemReference(
-    VkQueue                                   queue,
-    VkGpuMemory                              mem)
+ICD_EXPORT VkResult VKAPI vkQueueAddMemReferences(
+    VkQueue                                     queue,
+    uint32_t                                    count,
+    const VkGpuMemory*                          pMems)
 {
     NULLDRV_LOG_FUNC;
     return VK_SUCCESS;
 }
 
-ICD_EXPORT VkResult VKAPI vkQueueRemoveMemReference(
-    VkQueue                                   queue,
-    VkGpuMemory                              mem)
+ICD_EXPORT VkResult VKAPI vkQueueRemoveMemReferences(
+    VkQueue                                     queue,
+    uint32_t                                    count,
+    const VkGpuMemory*                          pMems)
 {
     NULLDRV_LOG_FUNC;
     return VK_SUCCESS;
diff --git a/include/vkLayer.h b/include/vkLayer.h
index 813e6872..53460c73 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -39,8 +39,8 @@ typedef struct VkLayerDispatchTable_
     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 @@ typedef struct VkLayerDispatchTable_
     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 77b70102..0edbfcf8 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -2210,8 +2210,8 @@ typedef VkResult (VKAPI *PFN_vkGetPhysicalDeviceExtensionInfo)(VkPhysicalGpu gpu
 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_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelin
 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 @@ VkResult VKAPI vkQueueSubmit(
     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 @@ void VKAPI vkCmdBindIndexBuffer(
     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 5dbf9626..01e4e558 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2053,21 +2053,26 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer
     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 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcNam
         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 0554d97e..3192a777 100644
--- a/layers/glave_snapshot.c
+++ b/layers/glave_snapshot.c
@@ -1305,12 +1305,17 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipe
     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 684cb225..50675789 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -975,9 +975,9 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueN
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory
             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 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueAddMemReference(VkQueue queue, VkGpuMemory
     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 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueRemoveMemReference(VkQueue queue, VkGpuMem
             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 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
     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 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcNam
         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 @@ VK_LAYER_EXPORT void* VKAPI vkGetProcAddr(VkPhysicalGpu gpu, const char* funcNam
         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 77040ef5..f8562838 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -340,15 +340,15 @@ VK_LAYER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCo
     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 @@ VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipe
     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/vk-layer-generate.py b/vk-layer-generate.py
index a74b4ebd..cb429aab 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -1103,7 +1103,7 @@ class ObjectTrackerSubcommand(Subcommand):
         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 6d5bd585..56b95c27 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -282,13 +282,15 @@ core = Extension(
              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 @@ core = Extension(
              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"),