venus: update venus-protocol headers

This takes vn_protocol_driver_{structs,commands,calls}.h and split them
by Vulkan handle types.  This enables us to split up vn_device.c in the
following commits without slowing down compile time too much.

Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Acked-by: Erik Faye-Lund <erik.faye-lund@collabora.com>
Reviewed-by: Ryan Neph <ryanneph@google.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/10117>

src/virtio/venus-protocol/vn_protocol_driver.h

@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC
@@ -14,7 +14,32 @@
 #include "vn_protocol_driver_types.h"
 #include "vn_protocol_driver_handles.h"
 #include "vn_protocol_driver_structs.h"
-#include "vn_protocol_driver_commands.h"
-#include "vn_protocol_driver_calls.h"
+#include "vn_protocol_driver_transport.h"
+#include "vn_protocol_driver_instance.h"
+#include "vn_protocol_driver_device.h"
+#include "vn_protocol_driver_queue.h"
+#include "vn_protocol_driver_fence.h"
+#include "vn_protocol_driver_semaphore.h"
+#include "vn_protocol_driver_event.h"
+#include "vn_protocol_driver_device_memory.h"
+#include "vn_protocol_driver_image.h"
+#include "vn_protocol_driver_image_view.h"
+#include "vn_protocol_driver_sampler.h"
+#include "vn_protocol_driver_sampler_ycbcr_conversion.h"
+#include "vn_protocol_driver_buffer.h"
+#include "vn_protocol_driver_buffer_view.h"
+#include "vn_protocol_driver_descriptor_pool.h"
+#include "vn_protocol_driver_descriptor_set.h"
+#include "vn_protocol_driver_descriptor_set_layout.h"
+#include "vn_protocol_driver_descriptor_update_template.h"
+#include "vn_protocol_driver_render_pass.h"
+#include "vn_protocol_driver_framebuffer.h"
+#include "vn_protocol_driver_query_pool.h"
+#include "vn_protocol_driver_shader_module.h"
+#include "vn_protocol_driver_pipeline.h"
+#include "vn_protocol_driver_pipeline_layout.h"
+#include "vn_protocol_driver_pipeline_cache.h"
+#include "vn_protocol_driver_command_pool.h"
+#include "vn_protocol_driver_command_buffer.h"
 
 #endif /* VN_PROTOCOL_DRIVER_H */

src/virtio/venus-protocol/vn_protocol_driver_buffer_view.h

@@ -0,0 +1,276 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_BUFFER_VIEW_H
+#define VN_PROTOCOL_DRIVER_BUFFER_VIEW_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkBufferViewCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkBufferViewCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkBufferViewCreateInfo_self(const VkBufferViewCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkDeviceSize(&val->offset);
+    size += vn_sizeof_VkDeviceSize(&val->range);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkBufferViewCreateInfo(const VkBufferViewCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkBufferViewCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkBufferViewCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkBufferViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferViewCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkBuffer(enc, &val->buffer);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkDeviceSize(enc, &val->offset);
+    vn_encode_VkDeviceSize(enc, &val->range);
+}
+
+static inline void
+vn_encode_VkBufferViewCreateInfo(struct vn_cs_encoder *enc, const VkBufferViewCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO });
+    vn_encode_VkBufferViewCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkBufferViewCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkBufferViewCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkBufferView(pView);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkBufferViewCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pView))
+        vn_encode_VkBufferView(enc, pView);
+}
+
+static inline size_t vn_sizeof_vkCreateBufferView_reply(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateBufferView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkBufferView(pView);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateBufferView_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkBufferView(dec, pView);
+    } else {
+        pView = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkBufferView(&bufferView);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyBufferView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkBufferView(enc, &bufferView);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyBufferView_reply(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyBufferView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip bufferView */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyBufferView_reply(struct vn_cs_decoder *dec, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyBufferView_EXT);
+
+    /* skip device */
+    /* skip bufferView */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateBufferView(device, pCreateInfo, pAllocator, pView);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateBufferView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateBufferView_reply(device, pCreateInfo, pAllocator, pView) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyBufferView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyBufferView(device, bufferView, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyBufferView(&submit->command, cmd_flags, device, bufferView, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyBufferView_reply(device, bufferView, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateBufferView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateBufferView(struct vn_instance *vn_instance, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateBufferView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit);
+}
+
+static inline void vn_call_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyBufferView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, bufferView, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyBufferView_reply(&submit.reply, device, bufferView, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyBufferView(struct vn_instance *vn_instance, VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyBufferView(vn_instance, 0, device, bufferView, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_BUFFER_VIEW_H */

src/virtio/venus-protocol/vn_protocol_driver_command_pool.h

@@ -0,0 +1,449 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_COMMAND_POOL_H
+#define VN_PROTOCOL_DRIVER_COMMAND_POOL_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkCommandPoolCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkCommandPoolCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkCommandPoolCreateInfo_self(const VkCommandPoolCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->queueFamilyIndex);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkCommandPoolCreateInfo(const VkCommandPoolCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkCommandPoolCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkCommandPoolCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkCommandPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndex);
+}
+
+static inline void
+vn_encode_VkCommandPoolCreateInfo(struct vn_cs_encoder *enc, const VkCommandPoolCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO });
+    vn_encode_VkCommandPoolCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkCommandPoolCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkCommandPoolCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
+    if (pCommandPool)
+        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkCommandPoolCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pCommandPool))
+        vn_encode_VkCommandPool(enc, pCommandPool);
+}
+
+static inline size_t vn_sizeof_vkCreateCommandPool_reply(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pCommandPool);
+    if (pCommandPool)
+        cmd_size += vn_sizeof_VkCommandPool(pCommandPool);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateCommandPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkCommandPool(dec, pCommandPool);
+    } else {
+        pCommandPool = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkCommandPool(enc, &commandPool);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyCommandPool_reply(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyCommandPool_EXT);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkCommandPool(enc, &commandPool);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkResetCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetCommandPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkCommandPool(&commandPool);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkTrimCommandPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkCommandPool(enc, &commandPool);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkTrimCommandPool_reply(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkTrimCommandPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkTrimCommandPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkTrimCommandPool_EXT);
+
+    /* skip device */
+    /* skip commandPool */
+    /* skip flags */
+}
+
+static inline void vn_submit_vkCreateCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateCommandPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pCommandPool);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateCommandPool_reply(device, pCreateInfo, pAllocator, pCommandPool) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyCommandPool(device, commandPool, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyCommandPool(&submit->command, cmd_flags, device, commandPool, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyCommandPool_reply(device, commandPool, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetCommandPool(device, commandPool, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetCommandPool_reply(device, commandPool, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkTrimCommandPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkTrimCommandPool(device, commandPool, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkTrimCommandPool(&submit->command, cmd_flags, device, commandPool, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkTrimCommandPool_reply(device, commandPool, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pCommandPool, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateCommandPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pCommandPool);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateCommandPool(struct vn_instance *vn_instance, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateCommandPool(vn_instance, 0, device, pCreateInfo, pAllocator, pCommandPool, &submit);
+}
+
+static inline void vn_call_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyCommandPool_reply(&submit.reply, device, commandPool, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyCommandPool(vn_instance, 0, device, commandPool, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetCommandPool_reply(&submit.reply, device, commandPool, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
+}
+
+static inline void vn_call_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkTrimCommandPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, commandPool, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkTrimCommandPool_reply(&submit.reply, device, commandPool, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkTrimCommandPool(struct vn_instance *vn_instance, VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkTrimCommandPool(vn_instance, 0, device, commandPool, flags, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_COMMAND_POOL_H */

src/virtio/venus-protocol/vn_protocol_driver_cs.h

@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC

src/virtio/venus-protocol/vn_protocol_driver_defines.h

@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC
@@ -14,6 +14,8 @@
 
 #include "vn_protocol_driver_cs.h"
 
+#define VN_SUBMIT_LOCAL_CMD_SIZE 256
+
 /* VkStructureType */
 #define VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA ((VkStructureType)1000384000)
 

src/virtio/venus-protocol/vn_protocol_driver_descriptor_pool.h

@@ -0,0 +1,398 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkDescriptorPoolSize */
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolSize(const VkDescriptorPoolSize *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkDescriptorType(&val->type);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorPoolSize(struct vn_cs_encoder *enc, const VkDescriptorPoolSize *val)
+{
+    vn_encode_VkDescriptorType(enc, &val->type);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+}
+
+/* struct VkDescriptorPoolCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolCreateInfo_self(const VkDescriptorPoolCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->maxSets);
+    size += vn_sizeof_uint32_t(&val->poolSizeCount);
+    if (val->pPoolSizes) {
+        size += vn_sizeof_array_size(val->poolSizeCount);
+        for (uint32_t i = 0; i < val->poolSizeCount; i++)
+            size += vn_sizeof_VkDescriptorPoolSize(&val->pPoolSizes[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorPoolCreateInfo(const VkDescriptorPoolCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorPoolCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorPoolCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->maxSets);
+    vn_encode_uint32_t(enc, &val->poolSizeCount);
+    if (val->pPoolSizes) {
+        vn_encode_array_size(enc, val->poolSizeCount);
+        for (uint32_t i = 0; i < val->poolSizeCount; i++)
+            vn_encode_VkDescriptorPoolSize(enc, &val->pPoolSizes[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorPoolCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorPoolCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO });
+    vn_encode_VkDescriptorPoolCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorPoolCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorPoolCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
+    if (pDescriptorPool)
+        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorPoolCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pDescriptorPool))
+        vn_encode_VkDescriptorPool(enc, pDescriptorPool);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorPool_reply(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorPool);
+    if (pDescriptorPool)
+        cmd_size += vn_sizeof_VkDescriptorPool(pDescriptorPool);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorPool(dec, pDescriptorPool);
+    } else {
+        pDescriptorPool = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorPool(enc, &descriptorPool);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorPool_EXT);
+
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetDescriptorPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorPool(enc, &descriptorPool);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkResetDescriptorPool_reply(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetDescriptorPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetDescriptorPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetDescriptorPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip flags */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateDescriptorPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorPool);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorPool_reply(device, pCreateInfo, pAllocator, pDescriptorPool) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyDescriptorPool(device, descriptorPool, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorPool_reply(device, descriptorPool, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetDescriptorPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetDescriptorPool(device, descriptorPool, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetDescriptorPool(&submit->command, cmd_flags, device, descriptorPool, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetDescriptorPool_reply(device, descriptorPool, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateDescriptorPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorPool);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateDescriptorPool(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorPool(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorPool, &submit);
+}
+
+static inline void vn_call_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyDescriptorPool_reply(&submit.reply, device, descriptorPool, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorPool(vn_instance, 0, device, descriptorPool, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetDescriptorPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, flags, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetDescriptorPool_reply(&submit.reply, device, descriptorPool, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetDescriptorPool(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetDescriptorPool(vn_instance, 0, device, descriptorPool, flags, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_POOL_H */

src/virtio/venus-protocol/vn_protocol_driver_descriptor_set.h

@@ -0,0 +1,744 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/*
+ * These structs/unions/commands are not included
+ *
+ *   vkUpdateDescriptorSetWithTemplate
+ */
+
+/* struct VkDescriptorSetVariableDescriptorCountAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->descriptorSetCount);
+    if (val->pDescriptorCounts) {
+        size += vn_sizeof_array_size(val->descriptorSetCount);
+        size += vn_sizeof_uint32_t_array(val->pDescriptorCounts, val->descriptorSetCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo(const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->descriptorSetCount);
+    if (val->pDescriptorCounts) {
+        vn_encode_array_size(enc, val->descriptorSetCount);
+        vn_encode_uint32_t_array(enc, val->pDescriptorCounts, val->descriptorSetCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO });
+    vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorSetAllocateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetAllocateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountAllocateInfo_self((const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetAllocateInfo_self(const VkDescriptorSetAllocateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDescriptorPool(&val->descriptorPool);
+    size += vn_sizeof_uint32_t(&val->descriptorSetCount);
+    if (val->pSetLayouts) {
+        size += vn_sizeof_array_size(val->descriptorSetCount);
+        for (uint32_t i = 0; i < val->descriptorSetCount; i++)
+            size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetAllocateInfo(const VkDescriptorSetAllocateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetAllocateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetAllocateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetAllocateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDescriptorSetVariableDescriptorCountAllocateInfo_self(enc, (const VkDescriptorSetVariableDescriptorCountAllocateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetAllocateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDescriptorPool(enc, &val->descriptorPool);
+    vn_encode_uint32_t(enc, &val->descriptorSetCount);
+    if (val->pSetLayouts) {
+        vn_encode_array_size(enc, val->descriptorSetCount);
+        for (uint32_t i = 0; i < val->descriptorSetCount; i++)
+            vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetAllocateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetAllocateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO });
+    vn_encode_VkDescriptorSetAllocateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetAllocateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorImageInfo */
+
+static inline size_t
+vn_sizeof_VkDescriptorImageInfo(const VkDescriptorImageInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkSampler(&val->sampler);
+    size += vn_sizeof_VkImageView(&val->imageView);
+    size += vn_sizeof_VkImageLayout(&val->imageLayout);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorImageInfo(struct vn_cs_encoder *enc, const VkDescriptorImageInfo *val)
+{
+    vn_encode_VkSampler(enc, &val->sampler);
+    vn_encode_VkImageView(enc, &val->imageView);
+    vn_encode_VkImageLayout(enc, &val->imageLayout);
+}
+
+/* struct VkDescriptorBufferInfo */
+
+static inline size_t
+vn_sizeof_VkDescriptorBufferInfo(const VkDescriptorBufferInfo *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkBuffer(&val->buffer);
+    size += vn_sizeof_VkDeviceSize(&val->offset);
+    size += vn_sizeof_VkDeviceSize(&val->range);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorBufferInfo(struct vn_cs_encoder *enc, const VkDescriptorBufferInfo *val)
+{
+    vn_encode_VkBuffer(enc, &val->buffer);
+    vn_encode_VkDeviceSize(enc, &val->offset);
+    vn_encode_VkDeviceSize(enc, &val->range);
+}
+
+/* struct VkWriteDescriptorSet chain */
+
+static inline size_t
+vn_sizeof_VkWriteDescriptorSet_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkWriteDescriptorSet_self(const VkWriteDescriptorSet *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDescriptorSet(&val->dstSet);
+    size += vn_sizeof_uint32_t(&val->dstBinding);
+    size += vn_sizeof_uint32_t(&val->dstArrayElement);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
+    if (val->pImageInfo) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkDescriptorImageInfo(&val->pImageInfo[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pBufferInfo) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkDescriptorBufferInfo(&val->pBufferInfo[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pTexelBufferView) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkBufferView(&val->pTexelBufferView[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkWriteDescriptorSet(const VkWriteDescriptorSet *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkWriteDescriptorSet_pnext(val->pNext);
+    size += vn_sizeof_VkWriteDescriptorSet_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkWriteDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkWriteDescriptorSet_self(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDescriptorSet(enc, &val->dstSet);
+    vn_encode_uint32_t(enc, &val->dstBinding);
+    vn_encode_uint32_t(enc, &val->dstArrayElement);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+    vn_encode_VkDescriptorType(enc, &val->descriptorType);
+    if (val->pImageInfo) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkDescriptorImageInfo(enc, &val->pImageInfo[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pBufferInfo) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkDescriptorBufferInfo(enc, &val->pBufferInfo[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pTexelBufferView) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkBufferView(enc, &val->pTexelBufferView[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkWriteDescriptorSet(struct vn_cs_encoder *enc, const VkWriteDescriptorSet *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET });
+    vn_encode_VkWriteDescriptorSet_pnext(enc, val->pNext);
+    vn_encode_VkWriteDescriptorSet_self(enc, val);
+}
+
+/* struct VkCopyDescriptorSet chain */
+
+static inline size_t
+vn_sizeof_VkCopyDescriptorSet_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkCopyDescriptorSet_self(const VkCopyDescriptorSet *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkDescriptorSet(&val->srcSet);
+    size += vn_sizeof_uint32_t(&val->srcBinding);
+    size += vn_sizeof_uint32_t(&val->srcArrayElement);
+    size += vn_sizeof_VkDescriptorSet(&val->dstSet);
+    size += vn_sizeof_uint32_t(&val->dstBinding);
+    size += vn_sizeof_uint32_t(&val->dstArrayElement);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkCopyDescriptorSet(const VkCopyDescriptorSet *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkCopyDescriptorSet_pnext(val->pNext);
+    size += vn_sizeof_VkCopyDescriptorSet_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkCopyDescriptorSet_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkCopyDescriptorSet_self(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkDescriptorSet(enc, &val->srcSet);
+    vn_encode_uint32_t(enc, &val->srcBinding);
+    vn_encode_uint32_t(enc, &val->srcArrayElement);
+    vn_encode_VkDescriptorSet(enc, &val->dstSet);
+    vn_encode_uint32_t(enc, &val->dstBinding);
+    vn_encode_uint32_t(enc, &val->dstArrayElement);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+}
+
+static inline void
+vn_encode_VkCopyDescriptorSet(struct vn_cs_encoder *enc, const VkCopyDescriptorSet *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET });
+    vn_encode_VkCopyDescriptorSet_pnext(enc, val->pNext);
+    vn_encode_VkCopyDescriptorSet_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pAllocateInfo);
+    if (pAllocateInfo)
+        cmd_size += vn_sizeof_VkDescriptorSetAllocateInfo(pAllocateInfo);
+    if (pDescriptorSets) {
+        cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkAllocateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pAllocateInfo))
+        vn_encode_VkDescriptorSetAllocateInfo(enc, pAllocateInfo);
+    if (pDescriptorSets) {
+        vn_encode_array_size(enc, pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkAllocateDescriptorSets_reply(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    if (pDescriptorSets) {
+        cmd_size += vn_sizeof_array_size(pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkAllocateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkAllocateDescriptorSets_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pAllocateInfo */
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, pAllocateInfo->descriptorSetCount);
+        for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; i++)
+            vn_decode_VkDescriptorSet(dec, &pDescriptorSets[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pDescriptorSets = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorPool(&descriptorPool);
+    cmd_size += vn_sizeof_uint32_t(&descriptorSetCount);
+    if (pDescriptorSets) {
+        cmd_size += vn_sizeof_array_size(descriptorSetCount);
+        for (uint32_t i = 0; i < descriptorSetCount; i++)
+            cmd_size += vn_sizeof_VkDescriptorSet(&pDescriptorSets[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkFreeDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorPool(enc, &descriptorPool);
+    vn_encode_uint32_t(enc, &descriptorSetCount);
+    if (pDescriptorSets) {
+        vn_encode_array_size(enc, descriptorSetCount);
+        for (uint32_t i = 0; i < descriptorSetCount; i++)
+            vn_encode_VkDescriptorSet(enc, &pDescriptorSets[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkFreeDescriptorSets_reply(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip descriptorSetCount */
+    /* skip pDescriptorSets */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkFreeDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkFreeDescriptorSets_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip descriptorPool */
+    /* skip descriptorSetCount */
+    /* skip pDescriptorSets */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&descriptorWriteCount);
+    if (pDescriptorWrites) {
+        cmd_size += vn_sizeof_array_size(descriptorWriteCount);
+        for (uint32_t i = 0; i < descriptorWriteCount; i++)
+            cmd_size += vn_sizeof_VkWriteDescriptorSet(&pDescriptorWrites[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&descriptorCopyCount);
+    if (pDescriptorCopies) {
+        cmd_size += vn_sizeof_array_size(descriptorCopyCount);
+        for (uint32_t i = 0; i < descriptorCopyCount; i++)
+            cmd_size += vn_sizeof_VkCopyDescriptorSet(&pDescriptorCopies[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkUpdateDescriptorSets(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &descriptorWriteCount);
+    if (pDescriptorWrites) {
+        vn_encode_array_size(enc, descriptorWriteCount);
+        for (uint32_t i = 0; i < descriptorWriteCount; i++)
+            vn_encode_VkWriteDescriptorSet(enc, &pDescriptorWrites[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &descriptorCopyCount);
+    if (pDescriptorCopies) {
+        vn_encode_array_size(enc, descriptorCopyCount);
+        for (uint32_t i = 0; i < descriptorCopyCount; i++)
+            vn_encode_VkCopyDescriptorSet(enc, &pDescriptorCopies[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkUpdateDescriptorSets_reply(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorWriteCount */
+    /* skip pDescriptorWrites */
+    /* skip descriptorCopyCount */
+    /* skip pDescriptorCopies */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkUpdateDescriptorSets_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkUpdateDescriptorSets_EXT);
+
+    /* skip device */
+    /* skip descriptorWriteCount */
+    /* skip pDescriptorWrites */
+    /* skip descriptorCopyCount */
+    /* skip pDescriptorCopies */
+}
+
+static inline void vn_submit_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkAllocateDescriptorSets(&submit->command, cmd_flags, device, pAllocateInfo, pDescriptorSets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkAllocateDescriptorSets_reply(device, pAllocateInfo, pDescriptorSets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkFreeDescriptorSets(&submit->command, cmd_flags, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkFreeDescriptorSets_reply(device, descriptorPool, descriptorSetCount, pDescriptorSets) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkUpdateDescriptorSets(&submit->command, cmd_flags, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkUpdateDescriptorSets_reply(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pAllocateInfo, pDescriptorSets, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkAllocateDescriptorSets_reply(&submit.reply, device, pAllocateInfo, pDescriptorSets);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkAllocateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkAllocateDescriptorSets(vn_instance, 0, device, pAllocateInfo, pDescriptorSets, &submit);
+}
+
+static inline VkResult vn_call_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkFreeDescriptorSets_reply(&submit.reply, device, descriptorPool, descriptorSetCount, pDescriptorSets);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkFreeDescriptorSets(struct vn_instance *vn_instance, VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkFreeDescriptorSets(vn_instance, 0, device, descriptorPool, descriptorSetCount, pDescriptorSets, &submit);
+}
+
+static inline void vn_call_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkUpdateDescriptorSets(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkUpdateDescriptorSets_reply(&submit.reply, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkUpdateDescriptorSets(struct vn_instance *vn_instance, VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkUpdateDescriptorSets(vn_instance, 0, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_H */

src/virtio/venus-protocol/vn_protocol_driver_descriptor_set_layout.h

@@ -0,0 +1,802 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_LAYOUT_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_LAYOUT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkDescriptorSetLayoutBinding */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->binding);
+    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    size += vn_sizeof_VkFlags(&val->stageFlags);
+    if (val->pImmutableSamplers) {
+        size += vn_sizeof_array_size(val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            size += vn_sizeof_VkSampler(&val->pImmutableSamplers[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBinding(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBinding *val)
+{
+    vn_encode_uint32_t(enc, &val->binding);
+    vn_encode_VkDescriptorType(enc, &val->descriptorType);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+    vn_encode_VkFlags(enc, &val->stageFlags);
+    if (val->pImmutableSamplers) {
+        vn_encode_array_size(enc, val->descriptorCount);
+        for (uint32_t i = 0; i < val->descriptorCount; i++)
+            vn_encode_VkSampler(enc, &val->pImmutableSamplers[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+/* struct VkDescriptorSetLayoutBindingFlagsCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->bindingCount);
+    if (val->pBindingFlags) {
+        size += vn_sizeof_array_size(val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            size += vn_sizeof_VkFlags(&val->pBindingFlags[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo(const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->bindingCount);
+    if (val->pBindingFlags) {
+        vn_encode_array_size(enc, val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            vn_encode_VkFlags(enc, &val->pBindingFlags[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutBindingFlagsCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO });
+    vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorSetLayoutCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetLayoutBindingFlagsCreateInfo_self((const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(const VkDescriptorSetLayoutCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->bindingCount);
+    if (val->pBindings) {
+        size += vn_sizeof_array_size(val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            size += vn_sizeof_VkDescriptorSetLayoutBinding(&val->pBindings[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkDescriptorSetLayoutBindingFlagsCreateInfo_self(enc, (const VkDescriptorSetLayoutBindingFlagsCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->bindingCount);
+    if (val->pBindings) {
+        vn_encode_array_size(enc, val->bindingCount);
+        for (uint32_t i = 0; i < val->bindingCount; i++)
+            vn_encode_VkDescriptorSetLayoutBinding(enc, &val->pBindings[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO });
+    vn_encode_VkDescriptorSetLayoutCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorSetLayoutCreateInfo_self(enc, val);
+}
+
+/* struct VkDescriptorSetVariableDescriptorCountLayoutSupport chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->maxVariableDescriptorCount);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->maxVariableDescriptorCount);
+}
+
+static inline void
+vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
+
+    assert(val->sType == stype);
+    vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext(dec, val->pNext);
+    vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->maxVariableDescriptorCount */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(val->pNext);
+    size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->maxVariableDescriptorCount */
+}
+
+static inline void
+vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetVariableDescriptorCountLayoutSupport *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT });
+    vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_pnext_partial(enc, val->pNext);
+    vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, val);
+}
+
+/* struct VkDescriptorSetLayoutSupport chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_self(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkBool32(&val->supported);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_self(val);
+
+    return size;
+}
+
+static inline void
+vn_decode_VkDescriptorSetLayoutSupport_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    VkBaseOutStructure *pnext = (VkBaseOutStructure *)val;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return;
+
+    vn_decode_VkStructureType(dec, &stype);
+    while (true) {
+        assert(pnext);
+        if (pnext->sType == stype)
+            break;
+    }
+
+    switch ((int32_t)pnext->sType) {
+    case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+        vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, pnext->pNext);
+        vn_decode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self(dec, (VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+        break;
+    default:
+        assert(false);
+        break;
+    }
+}
+
+static inline void
+vn_decode_VkDescriptorSetLayoutSupport_self(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkBool32(dec, &val->supported);
+}
+
+static inline void
+vn_decode_VkDescriptorSetLayoutSupport(struct vn_cs_decoder *dec, VkDescriptorSetLayoutSupport *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT);
+
+    assert(val->sType == stype);
+    vn_decode_VkDescriptorSetLayoutSupport_pnext(dec, val->pNext);
+    vn_decode_VkDescriptorSetLayoutSupport_self(dec, val);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(pnext->pNext);
+            size += vn_sizeof_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial((const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    /* skip val->supported */
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorSetLayoutSupport_partial(const VkDescriptorSetLayoutSupport *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_pnext_partial(val->pNext);
+    size += vn_sizeof_VkDescriptorSetLayoutSupport_self_partial(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, pnext->pNext);
+            vn_encode_VkDescriptorSetVariableDescriptorCountLayoutSupport_self_partial(enc, (const VkDescriptorSetVariableDescriptorCountLayoutSupport *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutSupport_self_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val)
+{
+    /* skip val->{sType,pNext} */
+    /* skip val->supported */
+}
+
+static inline void
+vn_encode_VkDescriptorSetLayoutSupport_partial(struct vn_cs_encoder *enc, const VkDescriptorSetLayoutSupport *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT });
+    vn_encode_VkDescriptorSetLayoutSupport_pnext_partial(enc, val->pNext);
+    vn_encode_VkDescriptorSetLayoutSupport_self_partial(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pSetLayout);
+    if (pSetLayout)
+        cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pSetLayout))
+        vn_encode_VkDescriptorSetLayout(enc, pSetLayout);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorSetLayout_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pSetLayout);
+    if (pSetLayout)
+        cmd_size += vn_sizeof_VkDescriptorSetLayout(pSetLayout);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorSetLayout_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorSetLayout(dec, pSetLayout);
+    } else {
+        pSetLayout = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorSetLayout(&descriptorSetLayout);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyDescriptorSetLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorSetLayout(enc, &descriptorSetLayout);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorSetLayout_reply(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorSetLayout */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyDescriptorSetLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorSetLayout_EXT);
+
+    /* skip device */
+    /* skip descriptorSetLayout */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pSupport);
+    if (pSupport)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport_partial(pSupport);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetDescriptorSetLayoutSupport(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorSetLayoutCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pSupport))
+        vn_encode_VkDescriptorSetLayoutSupport_partial(enc, pSupport);
+}
+
+static inline size_t vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pCreateInfo */
+    cmd_size += vn_sizeof_simple_pointer(pSupport);
+    if (pSupport)
+        cmd_size += vn_sizeof_VkDescriptorSetLayoutSupport(pSupport);
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkGetDescriptorSetLayoutSupport_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetDescriptorSetLayoutSupport_EXT);
+
+    /* skip device */
+    /* skip pCreateInfo */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorSetLayoutSupport(dec, pSupport);
+    } else {
+        pSupport = NULL;
+    }
+}
+
+static inline void vn_submit_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateDescriptorSetLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSetLayout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorSetLayout_reply(device, pCreateInfo, pAllocator, pSetLayout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyDescriptorSetLayout(&submit->command, cmd_flags, device, descriptorSetLayout, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorSetLayout_reply(device, descriptorSetLayout, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetDescriptorSetLayoutSupport(&submit->command, cmd_flags, device, pCreateInfo, pSupport);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetDescriptorSetLayoutSupport_reply(device, pCreateInfo, pSupport) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSetLayout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateDescriptorSetLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pSetLayout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorSetLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pSetLayout, &submit);
+}
+
+static inline void vn_call_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorSetLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorSetLayout, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyDescriptorSetLayout_reply(&submit.reply, device, descriptorSetLayout, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyDescriptorSetLayout(struct vn_instance *vn_instance, VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorSetLayout(vn_instance, 0, device, descriptorSetLayout, pAllocator, &submit);
+}
+
+static inline void vn_call_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pSupport, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkGetDescriptorSetLayoutSupport_reply(&submit.reply, device, pCreateInfo, pSupport);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkGetDescriptorSetLayoutSupport(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetDescriptorSetLayoutSupport(vn_instance, 0, device, pCreateInfo, pSupport, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_SET_LAYOUT_H */

src/virtio/venus-protocol/vn_protocol_driver_descriptor_update_template.h

@@ -0,0 +1,320 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_DESCRIPTOR_UPDATE_TEMPLATE_H
+#define VN_PROTOCOL_DRIVER_DESCRIPTOR_UPDATE_TEMPLATE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkDescriptorUpdateTemplateEntry */
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateEntry(const VkDescriptorUpdateTemplateEntry *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->dstBinding);
+    size += vn_sizeof_uint32_t(&val->dstArrayElement);
+    size += vn_sizeof_uint32_t(&val->descriptorCount);
+    size += vn_sizeof_VkDescriptorType(&val->descriptorType);
+    size += vn_sizeof_size_t(&val->offset);
+    size += vn_sizeof_size_t(&val->stride);
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateEntry(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateEntry *val)
+{
+    vn_encode_uint32_t(enc, &val->dstBinding);
+    vn_encode_uint32_t(enc, &val->dstArrayElement);
+    vn_encode_uint32_t(enc, &val->descriptorCount);
+    vn_encode_VkDescriptorType(enc, &val->descriptorType);
+    vn_encode_size_t(enc, &val->offset);
+    vn_encode_size_t(enc, &val->stride);
+}
+
+/* struct VkDescriptorUpdateTemplateCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->descriptorUpdateEntryCount);
+    if (val->pDescriptorUpdateEntries) {
+        size += vn_sizeof_array_size(val->descriptorUpdateEntryCount);
+        for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++)
+            size += vn_sizeof_VkDescriptorUpdateTemplateEntry(&val->pDescriptorUpdateEntries[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_VkDescriptorUpdateTemplateType(&val->templateType);
+    size += vn_sizeof_VkDescriptorSetLayout(&val->descriptorSetLayout);
+    size += vn_sizeof_VkPipelineBindPoint(&val->pipelineBindPoint);
+    size += vn_sizeof_VkPipelineLayout(&val->pipelineLayout);
+    size += vn_sizeof_uint32_t(&val->set);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->descriptorUpdateEntryCount);
+    if (val->pDescriptorUpdateEntries) {
+        vn_encode_array_size(enc, val->descriptorUpdateEntryCount);
+        for (uint32_t i = 0; i < val->descriptorUpdateEntryCount; i++)
+            vn_encode_VkDescriptorUpdateTemplateEntry(enc, &val->pDescriptorUpdateEntries[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkDescriptorUpdateTemplateType(enc, &val->templateType);
+    vn_encode_VkDescriptorSetLayout(enc, &val->descriptorSetLayout);
+    vn_encode_VkPipelineBindPoint(enc, &val->pipelineBindPoint);
+    vn_encode_VkPipelineLayout(enc, &val->pipelineLayout);
+    vn_encode_uint32_t(enc, &val->set);
+}
+
+static inline void
+vn_encode_VkDescriptorUpdateTemplateCreateInfo(struct vn_cs_encoder *enc, const VkDescriptorUpdateTemplateCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO });
+    vn_encode_VkDescriptorUpdateTemplateCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkDescriptorUpdateTemplateCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkDescriptorUpdateTemplateCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate);
+    if (pDescriptorUpdateTemplate)
+        cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkDescriptorUpdateTemplateCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pDescriptorUpdateTemplate))
+        vn_encode_VkDescriptorUpdateTemplate(enc, pDescriptorUpdateTemplate);
+}
+
+static inline size_t vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pDescriptorUpdateTemplate);
+    if (pDescriptorUpdateTemplate)
+        cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(pDescriptorUpdateTemplate);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateDescriptorUpdateTemplate_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkDescriptorUpdateTemplate(dec, pDescriptorUpdateTemplate);
+    } else {
+        pDescriptorUpdateTemplate = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkDescriptorUpdateTemplate(&descriptorUpdateTemplate);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyDescriptorUpdateTemplate(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkDescriptorUpdateTemplate(enc, &descriptorUpdateTemplate);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip descriptorUpdateTemplate */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyDescriptorUpdateTemplate_reply(struct vn_cs_decoder *dec, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyDescriptorUpdateTemplate_EXT);
+
+    /* skip device */
+    /* skip descriptorUpdateTemplate */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateDescriptorUpdateTemplate(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateDescriptorUpdateTemplate_reply(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyDescriptorUpdateTemplate(&submit->command, cmd_flags, device, descriptorUpdateTemplate, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyDescriptorUpdateTemplate_reply(device, descriptorUpdateTemplate, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateDescriptorUpdateTemplate_reply(&submit.reply, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateDescriptorUpdateTemplate(vn_instance, 0, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate, &submit);
+}
+
+static inline void vn_call_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, descriptorUpdateTemplate, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyDescriptorUpdateTemplate_reply(&submit.reply, device, descriptorUpdateTemplate, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyDescriptorUpdateTemplate(struct vn_instance *vn_instance, VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyDescriptorUpdateTemplate(vn_instance, 0, device, descriptorUpdateTemplate, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_DESCRIPTOR_UPDATE_TEMPLATE_H */

src/virtio/venus-protocol/vn_protocol_driver_event.h

@@ -0,0 +1,538 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_EVENT_H
+#define VN_PROTOCOL_DRIVER_EVENT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkEventCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkEventCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkEventCreateInfo_self(const VkEventCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkEventCreateInfo(const VkEventCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkEventCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkEventCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkEventCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkEventCreateInfo_self(struct vn_cs_encoder *enc, const VkEventCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+static inline void
+vn_encode_VkEventCreateInfo(struct vn_cs_encoder *enc, const VkEventCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EVENT_CREATE_INFO });
+    vn_encode_VkEventCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkEventCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkEventCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pEvent);
+    if (pEvent)
+        cmd_size += vn_sizeof_VkEvent(pEvent);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkEventCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pEvent))
+        vn_encode_VkEvent(enc, pEvent);
+}
+
+static inline size_t vn_sizeof_vkCreateEvent_reply(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pEvent);
+    if (pEvent)
+        cmd_size += vn_sizeof_VkEvent(pEvent);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateEvent_reply(struct vn_cs_decoder *dec, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateEvent_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkEvent(dec, pEvent);
+    } else {
+        pEvent = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyEvent_reply(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip event */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyEvent_EXT);
+
+    /* skip device */
+    /* skip event */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetEventStatus(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetEventStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+}
+
+static inline size_t vn_sizeof_vkGetEventStatus_reply(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetEventStatus_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip event */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetEventStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetEventStatus_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip event */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkSetEvent(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+}
+
+static inline size_t vn_sizeof_vkSetEvent_reply(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip event */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkSetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSetEvent_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip event */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkResetEvent(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkEvent(&event);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetEvent(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkEvent(enc, &event);
+}
+
+static inline size_t vn_sizeof_vkResetEvent_reply(VkDevice device, VkEvent event)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetEvent_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip event */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetEvent_reply(struct vn_cs_decoder *dec, VkDevice device, VkEvent event)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetEvent_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip event */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateEvent(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pEvent);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateEvent_reply(device, pCreateInfo, pAllocator, pEvent) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyEvent(device, event, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyEvent(&submit->command, cmd_flags, device, event, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyEvent_reply(device, event, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetEventStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetEventStatus(device, event);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetEventStatus(&submit->command, cmd_flags, device, event);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetEventStatus_reply(device, event) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkSetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSetEvent(device, event);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSetEvent(&submit->command, cmd_flags, device, event);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetEvent_reply(device, event) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetEvent(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkEvent event, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetEvent(device, event);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetEvent(&submit->command, cmd_flags, device, event);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetEvent_reply(device, event) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pEvent, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateEvent_reply(&submit.reply, device, pCreateInfo, pAllocator, pEvent);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateEvent(struct vn_instance *vn_instance, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateEvent(vn_instance, 0, device, pCreateInfo, pAllocator, pEvent, &submit);
+}
+
+static inline void vn_call_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyEvent_reply(&submit.reply, device, event, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyEvent(vn_instance, 0, device, event, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetEventStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetEventStatus_reply(&submit.reply, device, event);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetEventStatus(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetEventStatus(vn_instance, 0, device, event, &submit);
+}
+
+static inline VkResult vn_call_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkSetEvent_reply(&submit.reply, device, event);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkSetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetEvent(vn_instance, 0, device, event, &submit);
+}
+
+static inline VkResult vn_call_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetEvent(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, event, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetEvent_reply(&submit.reply, device, event);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetEvent(struct vn_instance *vn_instance, VkDevice device, VkEvent event)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetEvent(vn_instance, 0, device, event, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_EVENT_H */

src/virtio/venus-protocol/vn_protocol_driver_fence.h

@@ -0,0 +1,664 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_FENCE_H
+#define VN_PROTOCOL_DRIVER_FENCE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkExportFenceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkExportFenceCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExportFenceCreateInfo_self(const VkExportFenceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->handleTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExportFenceCreateInfo(const VkExportFenceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExportFenceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkExportFenceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExportFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExportFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExportFenceCreateInfo(struct vn_cs_encoder *enc, const VkExportFenceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO });
+    vn_encode_VkExportFenceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExportFenceCreateInfo_self(enc, val);
+}
+
+/* struct VkFenceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkFenceCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkFenceCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkExportFenceCreateInfo_self((const VkExportFenceCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFenceCreateInfo_self(const VkFenceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFenceCreateInfo(const VkFenceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFenceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFenceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFenceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkFenceCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExportFenceCreateInfo_self(enc, (const VkExportFenceCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFenceCreateInfo_self(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+static inline void
+vn_encode_VkFenceCreateInfo(struct vn_cs_encoder *enc, const VkFenceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO });
+    vn_encode_VkFenceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkFenceCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkFenceCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pFence);
+    if (pFence)
+        cmd_size += vn_sizeof_VkFence(pFence);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkFenceCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pFence))
+        vn_encode_VkFence(enc, pFence);
+}
+
+static inline size_t vn_sizeof_vkCreateFence_reply(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFence_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pFence);
+    if (pFence)
+        cmd_size += vn_sizeof_VkFence(pFence);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateFence_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateFence_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkFence(dec, pFence);
+    } else {
+        pFence = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkFence(&fence);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyFence(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkFence(enc, &fence);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyFence_reply(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFence_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip fence */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyFence_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyFence_EXT);
+
+    /* skip device */
+    /* skip fence */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&fenceCount);
+    if (pFences) {
+        cmd_size += vn_sizeof_array_size(fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            cmd_size += vn_sizeof_VkFence(&pFences[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &fenceCount);
+    if (pFences) {
+        vn_encode_array_size(enc, fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            vn_encode_VkFence(enc, &pFences[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkResetFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetFences_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkResetFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetFences_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkGetFenceStatus(VkDevice device, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkFence(&fence);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetFenceStatus(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkFence(enc, &fence);
+}
+
+static inline size_t vn_sizeof_vkGetFenceStatus_reply(VkDevice device, VkFence fence)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetFenceStatus_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip fence */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetFenceStatus_reply(struct vn_cs_decoder *dec, VkDevice device, VkFence fence)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetFenceStatus_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip fence */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_uint32_t(&fenceCount);
+    if (pFences) {
+        cmd_size += vn_sizeof_array_size(fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            cmd_size += vn_sizeof_VkFence(&pFences[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkBool32(&waitAll);
+    cmd_size += vn_sizeof_uint64_t(&timeout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkWaitForFences(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_uint32_t(enc, &fenceCount);
+    if (pFences) {
+        vn_encode_array_size(enc, fenceCount);
+        for (uint32_t i = 0; i < fenceCount; i++)
+            vn_encode_VkFence(enc, &pFences[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkBool32(enc, &waitAll);
+    vn_encode_uint64_t(enc, &timeout);
+}
+
+static inline size_t vn_sizeof_vkWaitForFences_reply(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitForFences_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+    /* skip waitAll */
+    /* skip timeout */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkWaitForFences_reply(struct vn_cs_decoder *dec, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkWaitForFences_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip fenceCount */
+    /* skip pFences */
+    /* skip waitAll */
+    /* skip timeout */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateFence(device, pCreateInfo, pAllocator, pFence);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateFence(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFence);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFence_reply(device, pCreateInfo, pAllocator, pFence) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyFence(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyFence(device, fence, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyFence(&submit->command, cmd_flags, device, fence, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFence_reply(device, fence, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetFences(device, fenceCount, pFences);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetFences(&submit->command, cmd_flags, device, fenceCount, pFences);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetFences_reply(device, fenceCount, pFences) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetFenceStatus(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFence fence, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetFenceStatus(device, fence);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetFenceStatus(&submit->command, cmd_flags, device, fence);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetFenceStatus_reply(device, fence) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkWaitForFences(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkWaitForFences(&submit->command, cmd_flags, device, fenceCount, pFences, waitAll, timeout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitForFences_reply(device, fenceCount, pFences, waitAll, timeout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFence, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateFence_reply(&submit.reply, device, pCreateInfo, pAllocator, pFence);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateFence(struct vn_instance *vn_instance, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFence(vn_instance, 0, device, pCreateInfo, pAllocator, pFence, &submit);
+}
+
+static inline void vn_call_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFence(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyFence_reply(&submit.reply, device, fence, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyFence(struct vn_instance *vn_instance, VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFence(vn_instance, 0, device, fence, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkResetFences_reply(&submit.reply, device, fenceCount, pFences);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkResetFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetFences(vn_instance, 0, device, fenceCount, pFences, &submit);
+}
+
+static inline VkResult vn_call_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetFenceStatus(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fence, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetFenceStatus_reply(&submit.reply, device, fence);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetFenceStatus(struct vn_instance *vn_instance, VkDevice device, VkFence fence)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetFenceStatus(vn_instance, 0, device, fence, &submit);
+}
+
+static inline VkResult vn_call_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitForFences(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, fenceCount, pFences, waitAll, timeout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkWaitForFences_reply(&submit.reply, device, fenceCount, pFences, waitAll, timeout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkWaitForFences(struct vn_instance *vn_instance, VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitForFences(vn_instance, 0, device, fenceCount, pFences, waitAll, timeout, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_FENCE_H */

src/virtio/venus-protocol/vn_protocol_driver_framebuffer.h

@@ -0,0 +1,467 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_FRAMEBUFFER_H
+#define VN_PROTOCOL_DRIVER_FRAMEBUFFER_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkFramebufferAttachmentImageInfo chain */
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentImageInfo_self(const VkFramebufferAttachmentImageInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkFlags(&val->usage);
+    size += vn_sizeof_uint32_t(&val->width);
+    size += vn_sizeof_uint32_t(&val->height);
+    size += vn_sizeof_uint32_t(&val->layerCount);
+    size += vn_sizeof_uint32_t(&val->viewFormatCount);
+    if (val->pViewFormats) {
+        size += vn_sizeof_array_size(val->viewFormatCount);
+        size += vn_sizeof_VkFormat_array(val->pViewFormats, val->viewFormatCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentImageInfo(const VkFramebufferAttachmentImageInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFramebufferAttachmentImageInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFramebufferAttachmentImageInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentImageInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentImageInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_uint32_t(enc, &val->width);
+    vn_encode_uint32_t(enc, &val->height);
+    vn_encode_uint32_t(enc, &val->layerCount);
+    vn_encode_uint32_t(enc, &val->viewFormatCount);
+    if (val->pViewFormats) {
+        vn_encode_array_size(enc, val->viewFormatCount);
+        vn_encode_VkFormat_array(enc, val->pViewFormats, val->viewFormatCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentImageInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentImageInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO });
+    vn_encode_VkFramebufferAttachmentImageInfo_pnext(enc, val->pNext);
+    vn_encode_VkFramebufferAttachmentImageInfo_self(enc, val);
+}
+
+/* struct VkFramebufferAttachmentsCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(const VkFramebufferAttachmentsCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_uint32_t(&val->attachmentImageInfoCount);
+    if (val->pAttachmentImageInfos) {
+        size += vn_sizeof_array_size(val->attachmentImageInfoCount);
+        for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++)
+            size += vn_sizeof_VkFramebufferAttachmentImageInfo(&val->pAttachmentImageInfos[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferAttachmentsCreateInfo(const VkFramebufferAttachmentsCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentsCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->attachmentImageInfoCount);
+    if (val->pAttachmentImageInfos) {
+        vn_encode_array_size(enc, val->attachmentImageInfoCount);
+        for (uint32_t i = 0; i < val->attachmentImageInfoCount; i++)
+            vn_encode_VkFramebufferAttachmentImageInfo(enc, &val->pAttachmentImageInfos[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkFramebufferAttachmentsCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferAttachmentsCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO });
+    vn_encode_VkFramebufferAttachmentsCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, val);
+}
+
+/* struct VkFramebufferCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkFramebufferCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkFramebufferCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkFramebufferAttachmentsCreateInfo_self((const VkFramebufferAttachmentsCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferCreateInfo_self(const VkFramebufferCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkRenderPass(&val->renderPass);
+    size += vn_sizeof_uint32_t(&val->attachmentCount);
+    if (val->pAttachments) {
+        size += vn_sizeof_array_size(val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            size += vn_sizeof_VkImageView(&val->pAttachments[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->width);
+    size += vn_sizeof_uint32_t(&val->height);
+    size += vn_sizeof_uint32_t(&val->layers);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkFramebufferCreateInfo(const VkFramebufferCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkFramebufferCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkFramebufferCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkFramebufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkFramebufferCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkFramebufferAttachmentsCreateInfo_self(enc, (const VkFramebufferAttachmentsCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkFramebufferCreateInfo_self(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkRenderPass(enc, &val->renderPass);
+    vn_encode_uint32_t(enc, &val->attachmentCount);
+    if (val->pAttachments) {
+        vn_encode_array_size(enc, val->attachmentCount);
+        for (uint32_t i = 0; i < val->attachmentCount; i++)
+            vn_encode_VkImageView(enc, &val->pAttachments[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->width);
+    vn_encode_uint32_t(enc, &val->height);
+    vn_encode_uint32_t(enc, &val->layers);
+}
+
+static inline void
+vn_encode_VkFramebufferCreateInfo(struct vn_cs_encoder *enc, const VkFramebufferCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO });
+    vn_encode_VkFramebufferCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkFramebufferCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkFramebufferCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pFramebuffer);
+    if (pFramebuffer)
+        cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkFramebufferCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pFramebuffer))
+        vn_encode_VkFramebuffer(enc, pFramebuffer);
+}
+
+static inline size_t vn_sizeof_vkCreateFramebuffer_reply(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateFramebuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pFramebuffer);
+    if (pFramebuffer)
+        cmd_size += vn_sizeof_VkFramebuffer(pFramebuffer);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateFramebuffer_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkFramebuffer(dec, pFramebuffer);
+    } else {
+        pFramebuffer = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkFramebuffer(&framebuffer);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyFramebuffer(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkFramebuffer(enc, &framebuffer);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyFramebuffer_reply(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip framebuffer */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyFramebuffer_reply(struct vn_cs_decoder *dec, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyFramebuffer_EXT);
+
+    /* skip device */
+    /* skip framebuffer */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateFramebuffer(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pFramebuffer);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateFramebuffer_reply(device, pCreateInfo, pAllocator, pFramebuffer) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyFramebuffer(device, framebuffer, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyFramebuffer(&submit->command, cmd_flags, device, framebuffer, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyFramebuffer_reply(device, framebuffer, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pFramebuffer, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateFramebuffer_reply(&submit.reply, device, pCreateInfo, pAllocator, pFramebuffer);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateFramebuffer(struct vn_instance *vn_instance, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateFramebuffer(vn_instance, 0, device, pCreateInfo, pAllocator, pFramebuffer, &submit);
+}
+
+static inline void vn_call_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFramebuffer(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, framebuffer, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyFramebuffer_reply(&submit.reply, device, framebuffer, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyFramebuffer(struct vn_instance *vn_instance, VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyFramebuffer(vn_instance, 0, device, framebuffer, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_FRAMEBUFFER_H */

src/virtio/venus-protocol/vn_protocol_driver_handles.h

@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC

src/virtio/venus-protocol/vn_protocol_driver_image_view.h

@@ -0,0 +1,376 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_IMAGE_VIEW_H
+#define VN_PROTOCOL_DRIVER_IMAGE_VIEW_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkImageViewUsageCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkImageViewUsageCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageViewUsageCreateInfo_self(const VkImageViewUsageCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->usage);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageViewUsageCreateInfo(const VkImageViewUsageCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageViewUsageCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImageViewUsageCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageViewUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageViewUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->usage);
+}
+
+static inline void
+vn_encode_VkImageViewUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageViewUsageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO });
+    vn_encode_VkImageViewUsageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageViewUsageCreateInfo_self(enc, val);
+}
+
+/* struct VkImageViewCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkImageViewCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkImageViewUsageCreateInfo_self((const VkImageViewUsageCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkImageViewCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkImageViewCreateInfo_self(const VkImageViewCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkImage(&val->image);
+    size += vn_sizeof_VkImageViewType(&val->viewType);
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkComponentMapping(&val->components);
+    size += vn_sizeof_VkImageSubresourceRange(&val->subresourceRange);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkImageViewCreateInfo(const VkImageViewCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkImageViewCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkImageViewCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkImageViewCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageViewUsageCreateInfo_self(enc, (const VkImageViewUsageCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageViewCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageViewCreateInfo_self(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkImage(enc, &val->image);
+    vn_encode_VkImageViewType(enc, &val->viewType);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkComponentMapping(enc, &val->components);
+    vn_encode_VkImageSubresourceRange(enc, &val->subresourceRange);
+}
+
+static inline void
+vn_encode_VkImageViewCreateInfo(struct vn_cs_encoder *enc, const VkImageViewCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO });
+    vn_encode_VkImageViewCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageViewCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkImageViewCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkImageView(pView);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkImageViewCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pView))
+        vn_encode_VkImageView(enc, pView);
+}
+
+static inline size_t vn_sizeof_vkCreateImageView_reply(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateImageView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pView);
+    if (pView)
+        cmd_size += vn_sizeof_VkImageView(pView);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateImageView_reply(struct vn_cs_decoder *dec, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateImageView_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkImageView(dec, pView);
+    } else {
+        pView = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkImageView(&imageView);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyImageView(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkImageView(enc, &imageView);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyImageView_reply(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyImageView_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip imageView */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyImageView_reply(struct vn_cs_decoder *dec, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyImageView_EXT);
+
+    /* skip device */
+    /* skip imageView */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateImageView(device, pCreateInfo, pAllocator, pView);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateImageView(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pView);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateImageView_reply(device, pCreateInfo, pAllocator, pView) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyImageView(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyImageView(device, imageView, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyImageView(&submit->command, cmd_flags, device, imageView, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyImageView_reply(device, imageView, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pView, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateImageView_reply(&submit.reply, device, pCreateInfo, pAllocator, pView);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateImageView(struct vn_instance *vn_instance, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateImageView(vn_instance, 0, device, pCreateInfo, pAllocator, pView, &submit);
+}
+
+static inline void vn_call_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyImageView(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, imageView, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyImageView_reply(&submit.reply, device, imageView, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyImageView(struct vn_instance *vn_instance, VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyImageView(vn_instance, 0, device, imageView, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_IMAGE_VIEW_H */

src/virtio/venus-protocol/vn_protocol_driver_info.h

@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC

src/virtio/venus-protocol/vn_protocol_driver_instance.h

@@ -0,0 +1,756 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_INSTANCE_H
+#define VN_PROTOCOL_DRIVER_INSTANCE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/*
+ * These structs/unions/commands are not included
+ *
+ *   vkGetInstanceProcAddr
+ */
+
+/* struct VkApplicationInfo chain */
+
+static inline size_t
+vn_sizeof_VkApplicationInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkApplicationInfo_self(const VkApplicationInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    if (val->pApplicationName) {
+        const size_t string_size = strlen(val->pApplicationName) + 1;
+        size += vn_sizeof_array_size(string_size);
+        size += vn_sizeof_blob_array(val->pApplicationName, string_size);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->applicationVersion);
+    if (val->pEngineName) {
+        const size_t string_size = strlen(val->pEngineName) + 1;
+        size += vn_sizeof_array_size(string_size);
+        size += vn_sizeof_blob_array(val->pEngineName, string_size);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->engineVersion);
+    size += vn_sizeof_uint32_t(&val->apiVersion);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkApplicationInfo(const VkApplicationInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkApplicationInfo_pnext(val->pNext);
+    size += vn_sizeof_VkApplicationInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkApplicationInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkApplicationInfo_self(struct vn_cs_encoder *enc, const VkApplicationInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    if (val->pApplicationName) {
+        const size_t string_size = strlen(val->pApplicationName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, val->pApplicationName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->applicationVersion);
+    if (val->pEngineName) {
+        const size_t string_size = strlen(val->pEngineName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, val->pEngineName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->engineVersion);
+    vn_encode_uint32_t(enc, &val->apiVersion);
+}
+
+static inline void
+vn_encode_VkApplicationInfo(struct vn_cs_encoder *enc, const VkApplicationInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_APPLICATION_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_APPLICATION_INFO });
+    vn_encode_VkApplicationInfo_pnext(enc, val->pNext);
+    vn_encode_VkApplicationInfo_self(enc, val);
+}
+
+/* struct VkInstanceCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkInstanceCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkInstanceCreateInfo_self(const VkInstanceCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_simple_pointer(val->pApplicationInfo);
+    if (val->pApplicationInfo)
+        size += vn_sizeof_VkApplicationInfo(val->pApplicationInfo);
+    size += vn_sizeof_uint32_t(&val->enabledLayerCount);
+    if (val->ppEnabledLayerNames) {
+        size += vn_sizeof_array_size(val->enabledLayerCount);
+        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
+            size += vn_sizeof_array_size(string_size);
+            size += vn_sizeof_blob_array(val->ppEnabledLayerNames[i], string_size);
+        }
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->enabledExtensionCount);
+    if (val->ppEnabledExtensionNames) {
+        size += vn_sizeof_array_size(val->enabledExtensionCount);
+        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
+            size += vn_sizeof_array_size(string_size);
+            size += vn_sizeof_blob_array(val->ppEnabledExtensionNames[i], string_size);
+        }
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkInstanceCreateInfo(const VkInstanceCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkInstanceCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkInstanceCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkInstanceCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkInstanceCreateInfo_self(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    if (vn_encode_simple_pointer(enc, val->pApplicationInfo))
+        vn_encode_VkApplicationInfo(enc, val->pApplicationInfo);
+    vn_encode_uint32_t(enc, &val->enabledLayerCount);
+    if (val->ppEnabledLayerNames) {
+        vn_encode_array_size(enc, val->enabledLayerCount);
+        for (uint32_t i = 0; i < val->enabledLayerCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledLayerNames[i]) + 1;
+            vn_encode_array_size(enc, string_size);
+            vn_encode_blob_array(enc, val->ppEnabledLayerNames[i], string_size);
+        }
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->enabledExtensionCount);
+    if (val->ppEnabledExtensionNames) {
+        vn_encode_array_size(enc, val->enabledExtensionCount);
+        for (uint32_t i = 0; i < val->enabledExtensionCount; i++) {
+            const size_t string_size = strlen(val->ppEnabledExtensionNames[i]) + 1;
+            vn_encode_array_size(enc, string_size);
+            vn_encode_blob_array(enc, val->ppEnabledExtensionNames[i], string_size);
+        }
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkInstanceCreateInfo(struct vn_cs_encoder *enc, const VkInstanceCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO });
+    vn_encode_VkInstanceCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkInstanceCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkInstanceCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pInstance);
+    if (pInstance)
+        cmd_size += vn_sizeof_VkInstance(pInstance);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkInstanceCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pInstance))
+        vn_encode_VkInstance(enc, pInstance);
+}
+
+static inline size_t vn_sizeof_vkCreateInstance_reply(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateInstance_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pInstance);
+    if (pInstance)
+        cmd_size += vn_sizeof_VkInstance(pInstance);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateInstance_reply(struct vn_cs_decoder *dec, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateInstance_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkInstance(dec, pInstance);
+    } else {
+        pInstance = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkInstance(&instance);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyInstance(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkInstance(enc, &instance);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyInstance_reply(VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyInstance_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip instance */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyInstance_reply(struct vn_cs_decoder *dec, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyInstance_EXT);
+
+    /* skip instance */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceVersion(uint32_t* pApiVersion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pApiVersion); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateInstanceVersion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_simple_pointer(enc, pApiVersion); /* out */
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceVersion_reply(uint32_t* pApiVersion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    cmd_size += vn_sizeof_simple_pointer(pApiVersion);
+    if (pApiVersion)
+        cmd_size += vn_sizeof_uint32_t(pApiVersion);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateInstanceVersion_reply(struct vn_cs_decoder *dec, uint32_t* pApiVersion)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceVersion_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pApiVersion);
+    } else {
+        pApiVersion = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkLayerProperties_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateInstanceLayerProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkLayerProperties_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceLayerProperties_reply(uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkLayerProperties(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateInstanceLayerProperties_reply(struct vn_cs_decoder *dec, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceLayerProperties_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkLayerProperties(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    if (pLayerName) {
+        const size_t string_size = strlen(pLayerName) + 1;
+        cmd_size += vn_sizeof_array_size(string_size);
+        cmd_size += vn_sizeof_blob_array(pLayerName, string_size);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkExtensionProperties_partial(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkEnumerateInstanceExtensionProperties(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (pLayerName) {
+        const size_t string_size = strlen(pLayerName) + 1;
+        vn_encode_array_size(enc, string_size);
+        vn_encode_blob_array(enc, pLayerName, string_size);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (vn_encode_simple_pointer(enc, pPropertyCount))
+        vn_encode_uint32_t(enc, pPropertyCount);
+    if (pProperties) {
+        vn_encode_array_size(enc, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_encode_VkExtensionProperties_partial(enc, &pProperties[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip pLayerName */
+    cmd_size += vn_sizeof_simple_pointer(pPropertyCount);
+    if (pPropertyCount)
+        cmd_size += vn_sizeof_uint32_t(pPropertyCount);
+    if (pProperties) {
+        cmd_size += vn_sizeof_array_size(*pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            cmd_size += vn_sizeof_VkExtensionProperties(&pProperties[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkEnumerateInstanceExtensionProperties_reply(struct vn_cs_decoder *dec, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkEnumerateInstanceExtensionProperties_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip pLayerName */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint32_t(dec, pPropertyCount);
+    } else {
+        pPropertyCount = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        vn_decode_array_size(dec, *pPropertyCount);
+        for (uint32_t i = 0; i < *pPropertyCount; i++)
+            vn_decode_VkExtensionProperties(dec, &pProperties[i]);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pProperties = NULL;
+    }
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateInstance(pCreateInfo, pAllocator, pInstance);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateInstance(&submit->command, cmd_flags, pCreateInfo, pAllocator, pInstance);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateInstance_reply(pCreateInfo, pAllocator, pInstance) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyInstance(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkInstance instance, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyInstance(instance, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyInstance(&submit->command, cmd_flags, instance, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyInstance_reply(instance, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pApiVersion, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateInstanceVersion(pApiVersion);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateInstanceVersion(&submit->command, cmd_flags, pApiVersion);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceVersion_reply(pApiVersion) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t* pPropertyCount, VkLayerProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateInstanceLayerProperties(pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateInstanceLayerProperties(&submit->command, cmd_flags, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceLayerProperties_reply(pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkEnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkEnumerateInstanceExtensionProperties(&submit->command, cmd_flags, pLayerName, pPropertyCount, pProperties);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkEnumerateInstanceExtensionProperties_reply(pLayerName, pPropertyCount, pProperties) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pCreateInfo, pAllocator, pInstance, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateInstance_reply(&submit.reply, pCreateInfo, pAllocator, pInstance);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateInstance(struct vn_instance *vn_instance, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateInstance(vn_instance, 0, pCreateInfo, pAllocator, pInstance, &submit);
+}
+
+static inline void vn_call_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyInstance(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, instance, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyInstance_reply(&submit.reply, instance, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyInstance(struct vn_instance *vn_instance, VkInstance instance, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyInstance(vn_instance, 0, instance, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceVersion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pApiVersion, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateInstanceVersion_reply(&submit.reply, pApiVersion);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateInstanceVersion(struct vn_instance *vn_instance, uint32_t* pApiVersion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceVersion(vn_instance, 0, pApiVersion, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateInstanceLayerProperties_reply(&submit.reply, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateInstanceLayerProperties(struct vn_instance *vn_instance, uint32_t* pPropertyCount, VkLayerProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceLayerProperties(vn_instance, 0, pPropertyCount, pProperties, &submit);
+}
+
+static inline VkResult vn_call_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pLayerName, pPropertyCount, pProperties, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkEnumerateInstanceExtensionProperties_reply(&submit.reply, pLayerName, pPropertyCount, pProperties);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkEnumerateInstanceExtensionProperties(struct vn_instance *vn_instance, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkEnumerateInstanceExtensionProperties(vn_instance, 0, pLayerName, pPropertyCount, pProperties, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_INSTANCE_H */

src/virtio/venus-protocol/vn_protocol_driver_pipeline_cache.h

@@ -0,0 +1,510 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_PIPELINE_CACHE_H
+#define VN_PROTOCOL_DRIVER_PIPELINE_CACHE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkPipelineCacheCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineCacheCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineCacheCreateInfo_self(const VkPipelineCacheCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_size_t(&val->initialDataSize);
+    if (val->pInitialData) {
+        size += vn_sizeof_array_size(val->initialDataSize);
+        size += vn_sizeof_blob_array(val->pInitialData, val->initialDataSize);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineCacheCreateInfo(const VkPipelineCacheCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineCacheCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineCacheCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineCacheCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineCacheCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_size_t(enc, &val->initialDataSize);
+    if (val->pInitialData) {
+        vn_encode_array_size(enc, val->initialDataSize);
+        vn_encode_blob_array(enc, val->pInitialData, val->initialDataSize);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPipelineCacheCreateInfo(struct vn_cs_encoder *enc, const VkPipelineCacheCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO });
+    vn_encode_VkPipelineCacheCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineCacheCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkPipelineCacheCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pPipelineCache);
+    if (pPipelineCache)
+        cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreatePipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkPipelineCacheCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pPipelineCache))
+        vn_encode_VkPipelineCache(enc, pPipelineCache);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineCache_reply(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineCache_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pPipelineCache);
+    if (pPipelineCache)
+        cmd_size += vn_sizeof_VkPipelineCache(pPipelineCache);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreatePipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineCache_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPipelineCache(dec, pPipelineCache);
+    } else {
+        pPipelineCache = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyPipelineCache(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &pipelineCache);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineCache_reply(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyPipelineCache_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineCache_EXT);
+
+    /* skip device */
+    /* skip pipelineCache */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&pipelineCache);
+    cmd_size += vn_sizeof_simple_pointer(pDataSize);
+    if (pDataSize)
+        cmd_size += vn_sizeof_size_t(pDataSize);
+    cmd_size += vn_sizeof_simple_pointer(pData); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetPipelineCacheData(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &pipelineCache);
+    if (vn_encode_simple_pointer(enc, pDataSize))
+        vn_encode_size_t(enc, pDataSize);
+    vn_encode_array_size(enc, pData ? *pDataSize : 0); /* out */
+}
+
+static inline size_t vn_sizeof_vkGetPipelineCacheData_reply(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pipelineCache */
+    cmd_size += vn_sizeof_simple_pointer(pDataSize);
+    if (pDataSize)
+        cmd_size += vn_sizeof_size_t(pDataSize);
+    if (pData) {
+        cmd_size += vn_sizeof_array_size(*pDataSize);
+        cmd_size += vn_sizeof_blob_array(pData, *pDataSize);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetPipelineCacheData_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetPipelineCacheData_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pipelineCache */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_size_t(dec, pDataSize);
+    } else {
+        pDataSize = NULL;
+    }
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, *pDataSize);
+        vn_decode_blob_array(dec, pData, array_size);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pData = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineCache(&dstCache);
+    cmd_size += vn_sizeof_uint32_t(&srcCacheCount);
+    if (pSrcCaches) {
+        cmd_size += vn_sizeof_array_size(srcCacheCount);
+        for (uint32_t i = 0; i < srcCacheCount; i++)
+            cmd_size += vn_sizeof_VkPipelineCache(&pSrcCaches[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkMergePipelineCaches(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineCache(enc, &dstCache);
+    vn_encode_uint32_t(enc, &srcCacheCount);
+    if (pSrcCaches) {
+        vn_encode_array_size(enc, srcCacheCount);
+        for (uint32_t i = 0; i < srcCacheCount; i++)
+            vn_encode_VkPipelineCache(enc, &pSrcCaches[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline size_t vn_sizeof_vkMergePipelineCaches_reply(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkMergePipelineCaches_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip dstCache */
+    /* skip srcCacheCount */
+    /* skip pSrcCaches */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkMergePipelineCaches_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkMergePipelineCaches_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip dstCache */
+    /* skip srcCacheCount */
+    /* skip pSrcCaches */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreatePipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreatePipelineCache(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineCache);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineCache_reply(device, pCreateInfo, pAllocator, pPipelineCache) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyPipelineCache(device, pipelineCache, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyPipelineCache(&submit->command, cmd_flags, device, pipelineCache, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineCache_reply(device, pipelineCache, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetPipelineCacheData(&submit->command, cmd_flags, device, pipelineCache, pDataSize, pData);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetPipelineCacheData_reply(device, pipelineCache, pDataSize, pData) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkMergePipelineCaches(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkMergePipelineCaches(&submit->command, cmd_flags, device, dstCache, srcCacheCount, pSrcCaches);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkMergePipelineCaches_reply(device, dstCache, srcCacheCount, pSrcCaches) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineCache, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreatePipelineCache_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineCache);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreatePipelineCache(struct vn_instance *vn_instance, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineCache(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineCache, &submit);
+}
+
+static inline void vn_call_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineCache(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyPipelineCache_reply(&submit.reply, device, pipelineCache, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyPipelineCache(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineCache(vn_instance, 0, device, pipelineCache, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPipelineCacheData(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineCache, pDataSize, pData, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetPipelineCacheData_reply(&submit.reply, device, pipelineCache, pDataSize, pData);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetPipelineCacheData(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetPipelineCacheData(vn_instance, 0, device, pipelineCache, pDataSize, pData, &submit);
+}
+
+static inline VkResult vn_call_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkMergePipelineCaches(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, dstCache, srcCacheCount, pSrcCaches, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkMergePipelineCaches_reply(&submit.reply, device, dstCache, srcCacheCount, pSrcCaches);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkMergePipelineCaches(struct vn_instance *vn_instance, VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkMergePipelineCaches(vn_instance, 0, device, dstCache, srcCacheCount, pSrcCaches, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_PIPELINE_CACHE_H */

src/virtio/venus-protocol/vn_protocol_driver_pipeline_layout.h

@@ -0,0 +1,320 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_PIPELINE_LAYOUT_H
+#define VN_PROTOCOL_DRIVER_PIPELINE_LAYOUT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkPushConstantRange */
+
+static inline size_t
+vn_sizeof_VkPushConstantRange(const VkPushConstantRange *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_VkFlags(&val->stageFlags);
+    size += vn_sizeof_uint32_t(&val->offset);
+    size += vn_sizeof_uint32_t(&val->size);
+    return size;
+}
+
+static inline void
+vn_encode_VkPushConstantRange(struct vn_cs_encoder *enc, const VkPushConstantRange *val)
+{
+    vn_encode_VkFlags(enc, &val->stageFlags);
+    vn_encode_uint32_t(enc, &val->offset);
+    vn_encode_uint32_t(enc, &val->size);
+}
+
+/* struct VkPipelineLayoutCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkPipelineLayoutCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkPipelineLayoutCreateInfo_self(const VkPipelineLayoutCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->setLayoutCount);
+    if (val->pSetLayouts) {
+        size += vn_sizeof_array_size(val->setLayoutCount);
+        for (uint32_t i = 0; i < val->setLayoutCount; i++)
+            size += vn_sizeof_VkDescriptorSetLayout(&val->pSetLayouts[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    size += vn_sizeof_uint32_t(&val->pushConstantRangeCount);
+    if (val->pPushConstantRanges) {
+        size += vn_sizeof_array_size(val->pushConstantRangeCount);
+        for (uint32_t i = 0; i < val->pushConstantRangeCount; i++)
+            size += vn_sizeof_VkPushConstantRange(&val->pPushConstantRanges[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkPipelineLayoutCreateInfo(const VkPipelineLayoutCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkPipelineLayoutCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkPipelineLayoutCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkPipelineLayoutCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkPipelineLayoutCreateInfo_self(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->setLayoutCount);
+    if (val->pSetLayouts) {
+        vn_encode_array_size(enc, val->setLayoutCount);
+        for (uint32_t i = 0; i < val->setLayoutCount; i++)
+            vn_encode_VkDescriptorSetLayout(enc, &val->pSetLayouts[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &val->pushConstantRangeCount);
+    if (val->pPushConstantRanges) {
+        vn_encode_array_size(enc, val->pushConstantRangeCount);
+        for (uint32_t i = 0; i < val->pushConstantRangeCount; i++)
+            vn_encode_VkPushConstantRange(enc, &val->pPushConstantRanges[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkPipelineLayoutCreateInfo(struct vn_cs_encoder *enc, const VkPipelineLayoutCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO });
+    vn_encode_VkPipelineLayoutCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkPipelineLayoutCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkPipelineLayoutCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pPipelineLayout);
+    if (pPipelineLayout)
+        cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreatePipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkPipelineLayoutCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pPipelineLayout))
+        vn_encode_VkPipelineLayout(enc, pPipelineLayout);
+}
+
+static inline size_t vn_sizeof_vkCreatePipelineLayout_reply(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pPipelineLayout);
+    if (pPipelineLayout)
+        cmd_size += vn_sizeof_VkPipelineLayout(pPipelineLayout);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreatePipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreatePipelineLayout_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkPipelineLayout(dec, pPipelineLayout);
+    } else {
+        pPipelineLayout = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkPipelineLayout(&pipelineLayout);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyPipelineLayout(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkPipelineLayout(enc, &pipelineLayout);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyPipelineLayout_reply(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip pipelineLayout */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyPipelineLayout_reply(struct vn_cs_decoder *dec, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyPipelineLayout_EXT);
+
+    /* skip device */
+    /* skip pipelineLayout */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreatePipelineLayout(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pPipelineLayout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreatePipelineLayout_reply(device, pCreateInfo, pAllocator, pPipelineLayout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyPipelineLayout(&submit->command, cmd_flags, device, pipelineLayout, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyPipelineLayout_reply(device, pipelineLayout, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pPipelineLayout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreatePipelineLayout_reply(&submit.reply, device, pCreateInfo, pAllocator, pPipelineLayout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreatePipelineLayout(struct vn_instance *vn_instance, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreatePipelineLayout(vn_instance, 0, device, pCreateInfo, pAllocator, pPipelineLayout, &submit);
+}
+
+static inline void vn_call_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineLayout(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pipelineLayout, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyPipelineLayout_reply(&submit.reply, device, pipelineLayout, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyPipelineLayout(struct vn_instance *vn_instance, VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyPipelineLayout(vn_instance, 0, device, pipelineLayout, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_PIPELINE_LAYOUT_H */

src/virtio/venus-protocol/vn_protocol_driver_query_pool.h

@@ -0,0 +1,488 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_QUERY_POOL_H
+#define VN_PROTOCOL_DRIVER_QUERY_POOL_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkQueryPoolCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkQueryPoolCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkQueryPoolCreateInfo_self(const VkQueryPoolCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkQueryType(&val->queryType);
+    size += vn_sizeof_uint32_t(&val->queryCount);
+    size += vn_sizeof_VkFlags(&val->pipelineStatistics);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkQueryPoolCreateInfo(const VkQueryPoolCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkQueryPoolCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkQueryPoolCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkQueryPoolCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkQueryPoolCreateInfo_self(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkQueryType(enc, &val->queryType);
+    vn_encode_uint32_t(enc, &val->queryCount);
+    vn_encode_VkFlags(enc, &val->pipelineStatistics);
+}
+
+static inline void
+vn_encode_VkQueryPoolCreateInfo(struct vn_cs_encoder *enc, const VkQueryPoolCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO });
+    vn_encode_VkQueryPoolCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkQueryPoolCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkQueryPoolCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pQueryPool);
+    if (pQueryPool)
+        cmd_size += vn_sizeof_VkQueryPool(pQueryPool);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkQueryPoolCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pQueryPool))
+        vn_encode_VkQueryPool(enc, pQueryPool);
+}
+
+static inline size_t vn_sizeof_vkCreateQueryPool_reply(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateQueryPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pQueryPool);
+    if (pQueryPool)
+        cmd_size += vn_sizeof_VkQueryPool(pQueryPool);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateQueryPool_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkQueryPool(dec, pQueryPool);
+    } else {
+        pQueryPool = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyQueryPool_reply(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyQueryPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyQueryPool_EXT);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&firstQuery);
+    cmd_size += vn_sizeof_uint32_t(&queryCount);
+    cmd_size += vn_sizeof_size_t(&dataSize);
+    cmd_size += vn_sizeof_simple_pointer(pData); /* out */
+    cmd_size += vn_sizeof_VkDeviceSize(&stride);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetQueryPoolResults(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &firstQuery);
+    vn_encode_uint32_t(enc, &queryCount);
+    vn_encode_size_t(enc, &dataSize);
+    vn_encode_array_size(enc, pData ? dataSize : 0); /* out */
+    vn_encode_VkDeviceSize(enc, &stride);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkGetQueryPoolResults_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+    /* skip dataSize */
+    if (pData) {
+        cmd_size += vn_sizeof_array_size(dataSize);
+        cmd_size += vn_sizeof_blob_array(pData, dataSize);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    /* skip stride */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetQueryPoolResults_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetQueryPoolResults_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+    /* skip dataSize */
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, dataSize);
+        vn_decode_blob_array(dec, pData, array_size);
+    } else {
+        vn_decode_array_size(dec, 0);
+        pData = NULL;
+    }
+    /* skip stride */
+    /* skip flags */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkQueryPool(&queryPool);
+    cmd_size += vn_sizeof_uint32_t(&firstQuery);
+    cmd_size += vn_sizeof_uint32_t(&queryCount);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkResetQueryPool(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkQueryPool(enc, &queryPool);
+    vn_encode_uint32_t(enc, &firstQuery);
+    vn_encode_uint32_t(enc, &queryCount);
+}
+
+static inline size_t vn_sizeof_vkResetQueryPool_reply(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkResetQueryPool_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkResetQueryPool_reply(struct vn_cs_decoder *dec, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkResetQueryPool_EXT);
+
+    /* skip device */
+    /* skip queryPool */
+    /* skip firstQuery */
+    /* skip queryCount */
+}
+
+static inline void vn_submit_vkCreateQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateQueryPool(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pQueryPool);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateQueryPool_reply(device, pCreateInfo, pAllocator, pQueryPool) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyQueryPool(device, queryPool, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyQueryPool(&submit->command, cmd_flags, device, queryPool, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyQueryPool_reply(device, queryPool, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetQueryPoolResults(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetQueryPoolResults_reply(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkResetQueryPool(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkResetQueryPool(device, queryPool, firstQuery, queryCount);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkResetQueryPool(&submit->command, cmd_flags, device, queryPool, firstQuery, queryCount);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkResetQueryPool_reply(device, queryPool, firstQuery, queryCount) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pQueryPool, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateQueryPool_reply(&submit.reply, device, pCreateInfo, pAllocator, pQueryPool);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateQueryPool(struct vn_instance *vn_instance, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateQueryPool(vn_instance, 0, device, pCreateInfo, pAllocator, pQueryPool, &submit);
+}
+
+static inline void vn_call_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyQueryPool_reply(&submit.reply, device, queryPool, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyQueryPool(vn_instance, 0, device, queryPool, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetQueryPoolResults(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetQueryPoolResults_reply(&submit.reply, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetQueryPoolResults(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetQueryPoolResults(vn_instance, 0, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags, &submit);
+}
+
+static inline void vn_call_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetQueryPool(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, queryPool, firstQuery, queryCount, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkResetQueryPool_reply(&submit.reply, device, queryPool, firstQuery, queryCount);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkResetQueryPool(struct vn_instance *vn_instance, VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkResetQueryPool(vn_instance, 0, device, queryPool, firstQuery, queryCount, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_QUERY_POOL_H */

src/virtio/venus-protocol/vn_protocol_driver_sampler.h

@@ -0,0 +1,396 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SAMPLER_H
+#define VN_PROTOCOL_DRIVER_SAMPLER_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkSamplerReductionModeCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerReductionModeCreateInfo_self(const VkSamplerReductionModeCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSamplerReductionMode(&val->reductionMode);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerReductionModeCreateInfo(const VkSamplerReductionModeCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerReductionModeCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerReductionModeCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSamplerReductionModeCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSamplerReductionModeCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkSamplerReductionMode(enc, &val->reductionMode);
+}
+
+static inline void
+vn_encode_VkSamplerReductionModeCreateInfo(struct vn_cs_encoder *enc, const VkSamplerReductionModeCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO });
+    vn_encode_VkSamplerReductionModeCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSamplerReductionModeCreateInfo_self(enc, val);
+}
+
+/* struct VkSamplerCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSamplerCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSamplerYcbcrConversionInfo_self((const VkSamplerYcbcrConversionInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSamplerCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSamplerReductionModeCreateInfo_self((const VkSamplerReductionModeCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerCreateInfo_self(const VkSamplerCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_VkFilter(&val->magFilter);
+    size += vn_sizeof_VkFilter(&val->minFilter);
+    size += vn_sizeof_VkSamplerMipmapMode(&val->mipmapMode);
+    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeU);
+    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeV);
+    size += vn_sizeof_VkSamplerAddressMode(&val->addressModeW);
+    size += vn_sizeof_float(&val->mipLodBias);
+    size += vn_sizeof_VkBool32(&val->anisotropyEnable);
+    size += vn_sizeof_float(&val->maxAnisotropy);
+    size += vn_sizeof_VkBool32(&val->compareEnable);
+    size += vn_sizeof_VkCompareOp(&val->compareOp);
+    size += vn_sizeof_float(&val->minLod);
+    size += vn_sizeof_float(&val->maxLod);
+    size += vn_sizeof_VkBorderColor(&val->borderColor);
+    size += vn_sizeof_VkBool32(&val->unnormalizedCoordinates);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerCreateInfo(const VkSamplerCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSamplerCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSamplerYcbcrConversionInfo_self(enc, (const VkSamplerYcbcrConversionInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSamplerCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSamplerReductionModeCreateInfo_self(enc, (const VkSamplerReductionModeCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSamplerCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkFilter(enc, &val->magFilter);
+    vn_encode_VkFilter(enc, &val->minFilter);
+    vn_encode_VkSamplerMipmapMode(enc, &val->mipmapMode);
+    vn_encode_VkSamplerAddressMode(enc, &val->addressModeU);
+    vn_encode_VkSamplerAddressMode(enc, &val->addressModeV);
+    vn_encode_VkSamplerAddressMode(enc, &val->addressModeW);
+    vn_encode_float(enc, &val->mipLodBias);
+    vn_encode_VkBool32(enc, &val->anisotropyEnable);
+    vn_encode_float(enc, &val->maxAnisotropy);
+    vn_encode_VkBool32(enc, &val->compareEnable);
+    vn_encode_VkCompareOp(enc, &val->compareOp);
+    vn_encode_float(enc, &val->minLod);
+    vn_encode_float(enc, &val->maxLod);
+    vn_encode_VkBorderColor(enc, &val->borderColor);
+    vn_encode_VkBool32(enc, &val->unnormalizedCoordinates);
+}
+
+static inline void
+vn_encode_VkSamplerCreateInfo(struct vn_cs_encoder *enc, const VkSamplerCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO });
+    vn_encode_VkSamplerCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSamplerCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkSamplerCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pSampler);
+    if (pSampler)
+        cmd_size += vn_sizeof_VkSampler(pSampler);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateSampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkSamplerCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pSampler))
+        vn_encode_VkSampler(enc, pSampler);
+}
+
+static inline size_t vn_sizeof_vkCreateSampler_reply(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSampler_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pSampler);
+    if (pSampler)
+        cmd_size += vn_sizeof_VkSampler(pSampler);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateSampler_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateSampler_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkSampler(dec, pSampler);
+    } else {
+        pSampler = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSampler(&sampler);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroySampler(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSampler(enc, &sampler);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroySampler_reply(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySampler_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip sampler */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroySampler_reply(struct vn_cs_decoder *dec, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroySampler_EXT);
+
+    /* skip device */
+    /* skip sampler */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateSampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateSampler(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSampler);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSampler_reply(device, pCreateInfo, pAllocator, pSampler) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroySampler(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroySampler(device, sampler, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroySampler(&submit->command, cmd_flags, device, sampler, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySampler_reply(device, sampler, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSampler, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateSampler_reply(&submit.reply, device, pCreateInfo, pAllocator, pSampler);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateSampler(struct vn_instance *vn_instance, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSampler(vn_instance, 0, device, pCreateInfo, pAllocator, pSampler, &submit);
+}
+
+static inline void vn_call_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySampler(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, sampler, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroySampler_reply(&submit.reply, device, sampler, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroySampler(struct vn_instance *vn_instance, VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySampler(vn_instance, 0, device, sampler, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SAMPLER_H */

src/virtio/venus-protocol/vn_protocol_driver_sampler_ycbcr_conversion.h

@@ -0,0 +1,282 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SAMPLER_YCBCR_CONVERSION_H
+#define VN_PROTOCOL_DRIVER_SAMPLER_YCBCR_CONVERSION_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkSamplerYcbcrConversionCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFormat(&val->format);
+    size += vn_sizeof_VkSamplerYcbcrModelConversion(&val->ycbcrModel);
+    size += vn_sizeof_VkSamplerYcbcrRange(&val->ycbcrRange);
+    size += vn_sizeof_VkComponentMapping(&val->components);
+    size += vn_sizeof_VkChromaLocation(&val->xChromaOffset);
+    size += vn_sizeof_VkChromaLocation(&val->yChromaOffset);
+    size += vn_sizeof_VkFilter(&val->chromaFilter);
+    size += vn_sizeof_VkBool32(&val->forceExplicitReconstruction);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSamplerYcbcrConversionCreateInfo(const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionCreateInfo_self(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkSamplerYcbcrModelConversion(enc, &val->ycbcrModel);
+    vn_encode_VkSamplerYcbcrRange(enc, &val->ycbcrRange);
+    vn_encode_VkComponentMapping(enc, &val->components);
+    vn_encode_VkChromaLocation(enc, &val->xChromaOffset);
+    vn_encode_VkChromaLocation(enc, &val->yChromaOffset);
+    vn_encode_VkFilter(enc, &val->chromaFilter);
+    vn_encode_VkBool32(enc, &val->forceExplicitReconstruction);
+}
+
+static inline void
+vn_encode_VkSamplerYcbcrConversionCreateInfo(struct vn_cs_encoder *enc, const VkSamplerYcbcrConversionCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO });
+    vn_encode_VkSamplerYcbcrConversionCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSamplerYcbcrConversionCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkSamplerYcbcrConversionCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion);
+    if (pYcbcrConversion)
+        cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateSamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkSamplerYcbcrConversionCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pYcbcrConversion))
+        vn_encode_VkSamplerYcbcrConversion(enc, pYcbcrConversion);
+}
+
+static inline size_t vn_sizeof_vkCreateSamplerYcbcrConversion_reply(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pYcbcrConversion);
+    if (pYcbcrConversion)
+        cmd_size += vn_sizeof_VkSamplerYcbcrConversion(pYcbcrConversion);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateSamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkSamplerYcbcrConversion(dec, pYcbcrConversion);
+    } else {
+        pYcbcrConversion = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSamplerYcbcrConversion(&ycbcrConversion);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroySamplerYcbcrConversion(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSamplerYcbcrConversion(enc, &ycbcrConversion);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroySamplerYcbcrConversion_reply(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip ycbcrConversion */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroySamplerYcbcrConversion_reply(struct vn_cs_decoder *dec, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT);
+
+    /* skip device */
+    /* skip ycbcrConversion */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateSamplerYcbcrConversion(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pYcbcrConversion);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSamplerYcbcrConversion_reply(device, pCreateInfo, pAllocator, pYcbcrConversion) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroySamplerYcbcrConversion(&submit->command, cmd_flags, device, ycbcrConversion, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySamplerYcbcrConversion_reply(device, ycbcrConversion, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateSamplerYcbcrConversion_reply(&submit.reply, device, pCreateInfo, pAllocator, pYcbcrConversion);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateSamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSamplerYcbcrConversion(vn_instance, 0, device, pCreateInfo, pAllocator, pYcbcrConversion, &submit);
+}
+
+static inline void vn_call_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, ycbcrConversion, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroySamplerYcbcrConversion_reply(&submit.reply, device, ycbcrConversion, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroySamplerYcbcrConversion(struct vn_instance *vn_instance, VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySamplerYcbcrConversion(vn_instance, 0, device, ycbcrConversion, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SAMPLER_YCBCR_CONVERSION_H */

src/virtio/venus-protocol/vn_protocol_driver_semaphore.h

@@ -0,0 +1,820 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SEMAPHORE_H
+#define VN_PROTOCOL_DRIVER_SEMAPHORE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkExportSemaphoreCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkExportSemaphoreCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkExportSemaphoreCreateInfo_self(const VkExportSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->handleTypes);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkExportSemaphoreCreateInfo(const VkExportSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkExportSemaphoreCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkExportSemaphoreCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkExportSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExportSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExportSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkExportSemaphoreCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO });
+    vn_encode_VkExportSemaphoreCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExportSemaphoreCreateInfo_self(enc, val);
+}
+
+/* struct VkSemaphoreCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkSemaphoreCreateInfo_pnext(const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+    size_t size = 0;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkExportSemaphoreCreateInfo_self((const VkExportSemaphoreCreateInfo *)pnext);
+            return size;
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            size += vn_sizeof_simple_pointer(pnext);
+            size += vn_sizeof_VkStructureType(&pnext->sType);
+            size += vn_sizeof_VkSemaphoreCreateInfo_pnext(pnext->pNext);
+            size += vn_sizeof_VkSemaphoreTypeCreateInfo_self((const VkSemaphoreTypeCreateInfo *)pnext);
+            return size;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreCreateInfo_self(const VkSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreCreateInfo(const VkSemaphoreCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSemaphoreCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSemaphoreCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSemaphoreCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExportSemaphoreCreateInfo_self(enc, (const VkExportSemaphoreCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkSemaphoreCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkSemaphoreTypeCreateInfo_self(enc, (const VkSemaphoreTypeCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSemaphoreCreateInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+}
+
+static inline void
+vn_encode_VkSemaphoreCreateInfo(struct vn_cs_encoder *enc, const VkSemaphoreCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO });
+    vn_encode_VkSemaphoreCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkSemaphoreCreateInfo_self(enc, val);
+}
+
+/* struct VkSemaphoreWaitInfo chain */
+
+static inline size_t
+vn_sizeof_VkSemaphoreWaitInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreWaitInfo_self(const VkSemaphoreWaitInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->semaphoreCount);
+    if (val->pSemaphores) {
+        size += vn_sizeof_array_size(val->semaphoreCount);
+        for (uint32_t i = 0; i < val->semaphoreCount; i++)
+            size += vn_sizeof_VkSemaphore(&val->pSemaphores[i]);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    if (val->pValues) {
+        size += vn_sizeof_array_size(val->semaphoreCount);
+        size += vn_sizeof_uint64_t_array(val->pValues, val->semaphoreCount);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreWaitInfo(const VkSemaphoreWaitInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSemaphoreWaitInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSemaphoreWaitInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSemaphoreWaitInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSemaphoreWaitInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->semaphoreCount);
+    if (val->pSemaphores) {
+        vn_encode_array_size(enc, val->semaphoreCount);
+        for (uint32_t i = 0; i < val->semaphoreCount; i++)
+            vn_encode_VkSemaphore(enc, &val->pSemaphores[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (val->pValues) {
+        vn_encode_array_size(enc, val->semaphoreCount);
+        vn_encode_uint64_t_array(enc, val->pValues, val->semaphoreCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkSemaphoreWaitInfo(struct vn_cs_encoder *enc, const VkSemaphoreWaitInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO });
+    vn_encode_VkSemaphoreWaitInfo_pnext(enc, val->pNext);
+    vn_encode_VkSemaphoreWaitInfo_self(enc, val);
+}
+
+/* struct VkSemaphoreSignalInfo chain */
+
+static inline size_t
+vn_sizeof_VkSemaphoreSignalInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreSignalInfo_self(const VkSemaphoreSignalInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkSemaphore(&val->semaphore);
+    size += vn_sizeof_uint64_t(&val->value);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkSemaphoreSignalInfo(const VkSemaphoreSignalInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkSemaphoreSignalInfo_pnext(val->pNext);
+    size += vn_sizeof_VkSemaphoreSignalInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkSemaphoreSignalInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkSemaphoreSignalInfo_self(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkSemaphore(enc, &val->semaphore);
+    vn_encode_uint64_t(enc, &val->value);
+}
+
+static inline void
+vn_encode_VkSemaphoreSignalInfo(struct vn_cs_encoder *enc, const VkSemaphoreSignalInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO });
+    vn_encode_VkSemaphoreSignalInfo_pnext(enc, val->pNext);
+    vn_encode_VkSemaphoreSignalInfo_self(enc, val);
+}
+
+static inline void
+vn_decode_VkSemaphoreSignalInfo_pnext(struct vn_cs_decoder *dec, const void *val)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        assert(false);
+}
+
+static inline void
+vn_decode_VkSemaphoreSignalInfo_self(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkSemaphore(dec, &val->semaphore);
+    vn_decode_uint64_t(dec, &val->value);
+}
+
+static inline void
+vn_decode_VkSemaphoreSignalInfo(struct vn_cs_decoder *dec, VkSemaphoreSignalInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    assert(stype == VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO);
+
+    assert(val->sType == stype);
+    vn_decode_VkSemaphoreSignalInfo_pnext(dec, val->pNext);
+    vn_decode_VkSemaphoreSignalInfo_self(dec, val);
+}
+
+static inline size_t vn_sizeof_vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkSemaphoreCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pSemaphore);
+    if (pSemaphore)
+        cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkSemaphoreCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pSemaphore))
+        vn_encode_VkSemaphore(enc, pSemaphore);
+}
+
+static inline size_t vn_sizeof_vkCreateSemaphore_reply(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateSemaphore_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pSemaphore);
+    if (pSemaphore)
+        cmd_size += vn_sizeof_VkSemaphore(pSemaphore);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateSemaphore_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkSemaphore(dec, pSemaphore);
+    } else {
+        pSemaphore = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSemaphore(&semaphore);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroySemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSemaphore(enc, &semaphore);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroySemaphore_reply(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroySemaphore_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip semaphore */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroySemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroySemaphore_EXT);
+
+    /* skip device */
+    /* skip semaphore */
+    /* skip pAllocator */
+}
+
+static inline size_t vn_sizeof_vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkSemaphore(&semaphore);
+    cmd_size += vn_sizeof_simple_pointer(pValue); /* out */
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkGetSemaphoreCounterValue(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkSemaphore(enc, &semaphore);
+    vn_encode_simple_pointer(enc, pValue); /* out */
+}
+
+static inline size_t vn_sizeof_vkGetSemaphoreCounterValue_reply(VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip semaphore */
+    cmd_size += vn_sizeof_simple_pointer(pValue);
+    if (pValue)
+        cmd_size += vn_sizeof_uint64_t(pValue);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkGetSemaphoreCounterValue_reply(struct vn_cs_decoder *dec, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkGetSemaphoreCounterValue_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip semaphore */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_uint64_t(dec, pValue);
+    } else {
+        pValue = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pWaitInfo);
+    if (pWaitInfo)
+        cmd_size += vn_sizeof_VkSemaphoreWaitInfo(pWaitInfo);
+    cmd_size += vn_sizeof_uint64_t(&timeout);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkWaitSemaphores(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pWaitInfo))
+        vn_encode_VkSemaphoreWaitInfo(enc, pWaitInfo);
+    vn_encode_uint64_t(enc, &timeout);
+}
+
+static inline size_t vn_sizeof_vkWaitSemaphores_reply(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWaitSemaphores_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pWaitInfo */
+    /* skip timeout */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkWaitSemaphores_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkWaitSemaphores_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pWaitInfo */
+    /* skip timeout */
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pSignalInfo);
+    if (pSignalInfo)
+        cmd_size += vn_sizeof_VkSemaphoreSignalInfo(pSignalInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSignalSemaphore(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pSignalInfo))
+        vn_encode_VkSemaphoreSignalInfo(enc, pSignalInfo);
+}
+
+static inline size_t vn_sizeof_vkSignalSemaphore_reply(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSignalSemaphore_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pSignalInfo */
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkSignalSemaphore_reply(struct vn_cs_decoder *dec, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSignalSemaphore_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pSignalInfo */
+
+    return ret;
+}
+
+static inline void vn_submit_vkCreateSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateSemaphore(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pSemaphore);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateSemaphore_reply(device, pCreateInfo, pAllocator, pSemaphore) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroySemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroySemaphore(device, semaphore, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroySemaphore(&submit->command, cmd_flags, device, semaphore, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroySemaphore_reply(device, semaphore, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkSemaphore semaphore, uint64_t* pValue, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkGetSemaphoreCounterValue(device, semaphore, pValue);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkGetSemaphoreCounterValue(&submit->command, cmd_flags, device, semaphore, pValue);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkGetSemaphoreCounterValue_reply(device, semaphore, pValue) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkWaitSemaphores(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkWaitSemaphores(device, pWaitInfo, timeout);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkWaitSemaphores(&submit->command, cmd_flags, device, pWaitInfo, timeout);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWaitSemaphores_reply(device, pWaitInfo, timeout) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkSignalSemaphore(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSignalSemaphore(device, pSignalInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSignalSemaphore(&submit->command, cmd_flags, device, pSignalInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSignalSemaphore_reply(device, pSignalInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pSemaphore, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateSemaphore_reply(&submit.reply, device, pCreateInfo, pAllocator, pSemaphore);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateSemaphore(vn_instance, 0, device, pCreateInfo, pAllocator, pSemaphore, &submit);
+}
+
+static inline void vn_call_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroySemaphore_reply(&submit.reply, device, semaphore, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroySemaphore(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroySemaphore(vn_instance, 0, device, semaphore, pAllocator, &submit);
+}
+
+static inline VkResult vn_call_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetSemaphoreCounterValue(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, semaphore, pValue, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkGetSemaphoreCounterValue_reply(&submit.reply, device, semaphore, pValue);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkGetSemaphoreCounterValue(struct vn_instance *vn_instance, VkDevice device, VkSemaphore semaphore, uint64_t* pValue)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkGetSemaphoreCounterValue(vn_instance, 0, device, semaphore, pValue, &submit);
+}
+
+static inline VkResult vn_call_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitSemaphores(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pWaitInfo, timeout, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkWaitSemaphores_reply(&submit.reply, device, pWaitInfo, timeout);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkWaitSemaphores(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWaitSemaphores(vn_instance, 0, device, pWaitInfo, timeout, &submit);
+}
+
+static inline VkResult vn_call_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSignalSemaphore(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pSignalInfo, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkSignalSemaphore_reply(&submit.reply, device, pSignalInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkSignalSemaphore(struct vn_instance *vn_instance, VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSignalSemaphore(vn_instance, 0, device, pSignalInfo, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SEMAPHORE_H */

src/virtio/venus-protocol/vn_protocol_driver_shader_module.h

@@ -0,0 +1,282 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_SHADER_MODULE_H
+#define VN_PROTOCOL_DRIVER_SHADER_MODULE_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkShaderModuleCreateInfo chain */
+
+static inline size_t
+vn_sizeof_VkShaderModuleCreateInfo_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkShaderModuleCreateInfo_self(const VkShaderModuleCreateInfo *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_size_t(&val->codeSize);
+    if (val->pCode) {
+        size += vn_sizeof_array_size(val->codeSize / 4);
+        size += vn_sizeof_uint32_t_array(val->pCode, val->codeSize / 4);
+    } else {
+        size += vn_sizeof_array_size(0);
+    }
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkShaderModuleCreateInfo(const VkShaderModuleCreateInfo *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkShaderModuleCreateInfo_pnext(val->pNext);
+    size += vn_sizeof_VkShaderModuleCreateInfo_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkShaderModuleCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkShaderModuleCreateInfo_self(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_size_t(enc, &val->codeSize);
+    if (val->pCode) {
+        vn_encode_array_size(enc, val->codeSize / 4);
+        vn_encode_uint32_t_array(enc, val->pCode, val->codeSize / 4);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkShaderModuleCreateInfo(struct vn_cs_encoder *enc, const VkShaderModuleCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO });
+    vn_encode_VkShaderModuleCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkShaderModuleCreateInfo_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkShaderModuleCreateInfo(pCreateInfo);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+    cmd_size += vn_sizeof_simple_pointer(pShaderModule);
+    if (pShaderModule)
+        cmd_size += vn_sizeof_VkShaderModule(pShaderModule);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkShaderModuleCreateInfo(enc, pCreateInfo);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+    if (vn_encode_simple_pointer(enc, pShaderModule))
+        vn_encode_VkShaderModule(enc, pShaderModule);
+}
+
+static inline size_t vn_sizeof_vkCreateShaderModule_reply(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateShaderModule_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    VkResult ret;
+    cmd_size += vn_sizeof_VkResult(&ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    cmd_size += vn_sizeof_simple_pointer(pShaderModule);
+    if (pShaderModule)
+        cmd_size += vn_sizeof_VkShaderModule(pShaderModule);
+
+    return cmd_size;
+}
+
+static inline VkResult vn_decode_vkCreateShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateShaderModule_EXT);
+
+    VkResult ret;
+    vn_decode_VkResult(dec, &ret);
+    /* skip device */
+    /* skip pCreateInfo */
+    /* skip pAllocator */
+    if (vn_decode_simple_pointer(dec)) {
+        vn_decode_VkShaderModule(dec, pShaderModule);
+    } else {
+        pShaderModule = NULL;
+    }
+
+    return ret;
+}
+
+static inline size_t vn_sizeof_vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_VkDevice(&device);
+    cmd_size += vn_sizeof_VkShaderModule(&shaderModule);
+    cmd_size += vn_sizeof_simple_pointer(pAllocator);
+    if (pAllocator)
+        assert(false);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyShaderModule(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_VkDevice(enc, &device);
+    vn_encode_VkShaderModule(enc, &shaderModule);
+    if (vn_encode_simple_pointer(enc, pAllocator))
+        assert(false);
+}
+
+static inline size_t vn_sizeof_vkDestroyShaderModule_reply(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyShaderModule_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip device */
+    /* skip shaderModule */
+    /* skip pAllocator */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyShaderModule_reply(struct vn_cs_decoder *dec, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyShaderModule_EXT);
+
+    /* skip device */
+    /* skip shaderModule */
+    /* skip pAllocator */
+}
+
+static inline void vn_submit_vkCreateShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateShaderModule(&submit->command, cmd_flags, device, pCreateInfo, pAllocator, pShaderModule);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateShaderModule_reply(device, pCreateInfo, pAllocator, pShaderModule) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyShaderModule(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyShaderModule(device, shaderModule, pAllocator);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyShaderModule(&submit->command, cmd_flags, device, shaderModule, pAllocator);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyShaderModule_reply(device, shaderModule, pAllocator) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline VkResult vn_call_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, pCreateInfo, pAllocator, pShaderModule, &submit);
+    if (submit.reply_bo) {
+        const VkResult ret = vn_decode_vkCreateShaderModule_reply(&submit.reply, device, pCreateInfo, pAllocator, pShaderModule);
+        vn_renderer_bo_unref(submit.reply_bo);
+        return ret;
+    } else {
+        return VK_ERROR_OUT_OF_HOST_MEMORY;
+    }
+}
+
+static inline void vn_async_vkCreateShaderModule(struct vn_instance *vn_instance, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateShaderModule(vn_instance, 0, device, pCreateInfo, pAllocator, pShaderModule, &submit);
+}
+
+static inline void vn_call_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyShaderModule(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, device, shaderModule, pAllocator, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyShaderModule_reply(&submit.reply, device, shaderModule, pAllocator);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyShaderModule(struct vn_instance *vn_instance, VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyShaderModule(vn_instance, 0, device, shaderModule, pAllocator, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_SHADER_MODULE_H */

src/virtio/venus-protocol/vn_protocol_driver_transport.h

@@ -0,0 +1,746 @@
+/* This file is generated by venus-protocol git-2564dba1. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_DRIVER_TRANSPORT_H
+#define VN_PROTOCOL_DRIVER_TRANSPORT_H
+
+#include "vn_device.h"
+#include "vn_protocol_driver_structs.h"
+
+/* struct VkCommandStreamDescriptionMESA */
+
+static inline size_t
+vn_sizeof_VkCommandStreamDescriptionMESA(const VkCommandStreamDescriptionMESA *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->resourceId);
+    size += vn_sizeof_size_t(&val->offset);
+    size += vn_sizeof_size_t(&val->size);
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandStreamDescriptionMESA(struct vn_cs_encoder *enc, const VkCommandStreamDescriptionMESA *val)
+{
+    vn_encode_uint32_t(enc, &val->resourceId);
+    vn_encode_size_t(enc, &val->offset);
+    vn_encode_size_t(enc, &val->size);
+}
+
+/* struct VkCommandStreamDependencyMESA */
+
+static inline size_t
+vn_sizeof_VkCommandStreamDependencyMESA(const VkCommandStreamDependencyMESA *val)
+{
+    size_t size = 0;
+    size += vn_sizeof_uint32_t(&val->srcCommandStream);
+    size += vn_sizeof_uint32_t(&val->dstCommandStream);
+    return size;
+}
+
+static inline void
+vn_encode_VkCommandStreamDependencyMESA(struct vn_cs_encoder *enc, const VkCommandStreamDependencyMESA *val)
+{
+    vn_encode_uint32_t(enc, &val->srcCommandStream);
+    vn_encode_uint32_t(enc, &val->dstCommandStream);
+}
+
+/* struct VkRingCreateInfoMESA chain */
+
+static inline size_t
+vn_sizeof_VkRingCreateInfoMESA_pnext(const void *val)
+{
+    /* no known/supported struct */
+    return vn_sizeof_simple_pointer(NULL);
+}
+
+static inline size_t
+vn_sizeof_VkRingCreateInfoMESA_self(const VkRingCreateInfoMESA *val)
+{
+    size_t size = 0;
+    /* skip val->{sType,pNext} */
+    size += vn_sizeof_VkFlags(&val->flags);
+    size += vn_sizeof_uint32_t(&val->resourceId);
+    size += vn_sizeof_size_t(&val->offset);
+    size += vn_sizeof_size_t(&val->size);
+    size += vn_sizeof_uint64_t(&val->idleTimeout);
+    size += vn_sizeof_size_t(&val->headOffset);
+    size += vn_sizeof_size_t(&val->tailOffset);
+    size += vn_sizeof_size_t(&val->statusOffset);
+    size += vn_sizeof_size_t(&val->bufferOffset);
+    size += vn_sizeof_size_t(&val->bufferSize);
+    size += vn_sizeof_size_t(&val->extraOffset);
+    size += vn_sizeof_size_t(&val->extraSize);
+    return size;
+}
+
+static inline size_t
+vn_sizeof_VkRingCreateInfoMESA(const VkRingCreateInfoMESA *val)
+{
+    size_t size = 0;
+
+    size += vn_sizeof_VkStructureType(&val->sType);
+    size += vn_sizeof_VkRingCreateInfoMESA_pnext(val->pNext);
+    size += vn_sizeof_VkRingCreateInfoMESA_self(val);
+
+    return size;
+}
+
+static inline void
+vn_encode_VkRingCreateInfoMESA_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkRingCreateInfoMESA_self(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_uint32_t(enc, &val->resourceId);
+    vn_encode_size_t(enc, &val->offset);
+    vn_encode_size_t(enc, &val->size);
+    vn_encode_uint64_t(enc, &val->idleTimeout);
+    vn_encode_size_t(enc, &val->headOffset);
+    vn_encode_size_t(enc, &val->tailOffset);
+    vn_encode_size_t(enc, &val->statusOffset);
+    vn_encode_size_t(enc, &val->bufferOffset);
+    vn_encode_size_t(enc, &val->bufferSize);
+    vn_encode_size_t(enc, &val->extraOffset);
+    vn_encode_size_t(enc, &val->extraSize);
+}
+
+static inline void
+vn_encode_VkRingCreateInfoMESA(struct vn_cs_encoder *enc, const VkRingCreateInfoMESA *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_RING_CREATE_INFO_MESA });
+    vn_encode_VkRingCreateInfoMESA_pnext(enc, val->pNext);
+    vn_encode_VkRingCreateInfoMESA_self(enc, val);
+}
+
+static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA(const VkCommandStreamDescriptionMESA* pStream)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_simple_pointer(pStream);
+    if (pStream)
+        cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(pStream);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSetReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    if (vn_encode_simple_pointer(enc, pStream))
+        vn_encode_VkCommandStreamDescriptionMESA(enc, pStream);
+}
+
+static inline size_t vn_sizeof_vkSetReplyCommandStreamMESA_reply(const VkCommandStreamDescriptionMESA* pStream)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip pStream */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkSetReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, const VkCommandStreamDescriptionMESA* pStream)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT);
+
+    /* skip pStream */
+}
+
+static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA(size_t position)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_size_t(&position);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkSeekReplyCommandStreamMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, size_t position)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_size_t(enc, &position);
+}
+
+static inline size_t vn_sizeof_vkSeekReplyCommandStreamMESA_reply(size_t position)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip position */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkSeekReplyCommandStreamMESA_reply(struct vn_cs_decoder *dec, size_t position)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT);
+
+    /* skip position */
+}
+
+static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint32_t(&streamCount);
+    if (pStreams) {
+        cmd_size += vn_sizeof_array_size(streamCount);
+        for (uint32_t i = 0; i < streamCount; i++)
+            cmd_size += vn_sizeof_VkCommandStreamDescriptionMESA(&pStreams[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    if (pReplyPositions) {
+        cmd_size += vn_sizeof_array_size(streamCount);
+        cmd_size += vn_sizeof_size_t_array(pReplyPositions, streamCount);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_uint32_t(&dependencyCount);
+    if (pDependencies) {
+        cmd_size += vn_sizeof_array_size(dependencyCount);
+        for (uint32_t i = 0; i < dependencyCount; i++)
+            cmd_size += vn_sizeof_VkCommandStreamDependencyMESA(&pDependencies[i]);
+    } else {
+        cmd_size += vn_sizeof_array_size(0);
+    }
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkExecuteCommandStreamsMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint32_t(enc, &streamCount);
+    if (pStreams) {
+        vn_encode_array_size(enc, streamCount);
+        for (uint32_t i = 0; i < streamCount; i++)
+            vn_encode_VkCommandStreamDescriptionMESA(enc, &pStreams[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    if (pReplyPositions) {
+        vn_encode_array_size(enc, streamCount);
+        vn_encode_size_t_array(enc, pReplyPositions, streamCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_uint32_t(enc, &dependencyCount);
+    if (pDependencies) {
+        vn_encode_array_size(enc, dependencyCount);
+        for (uint32_t i = 0; i < dependencyCount; i++)
+            vn_encode_VkCommandStreamDependencyMESA(enc, &pDependencies[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkExecuteCommandStreamsMESA_reply(uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip streamCount */
+    /* skip pStreams */
+    /* skip pReplyPositions */
+    /* skip dependencyCount */
+    /* skip pDependencies */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkExecuteCommandStreamsMESA_reply(struct vn_cs_decoder *dec, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT);
+
+    /* skip streamCount */
+    /* skip pStreams */
+    /* skip pReplyPositions */
+    /* skip dependencyCount */
+    /* skip pDependencies */
+    /* skip flags */
+}
+
+static inline size_t vn_sizeof_vkCreateRingMESA(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+    cmd_size += vn_sizeof_simple_pointer(pCreateInfo);
+    if (pCreateInfo)
+        cmd_size += vn_sizeof_VkRingCreateInfoMESA(pCreateInfo);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkCreateRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+    if (vn_encode_simple_pointer(enc, pCreateInfo))
+        vn_encode_VkRingCreateInfoMESA(enc, pCreateInfo);
+}
+
+static inline size_t vn_sizeof_vkCreateRingMESA_reply(uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkCreateRingMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+    /* skip pCreateInfo */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkCreateRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkCreateRingMESA_EXT);
+
+    /* skip ring */
+    /* skip pCreateInfo */
+}
+
+static inline size_t vn_sizeof_vkDestroyRingMESA(uint64_t ring)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkDestroyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+}
+
+static inline size_t vn_sizeof_vkDestroyRingMESA_reply(uint64_t ring)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkDestroyRingMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkDestroyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkDestroyRingMESA_EXT);
+
+    /* skip ring */
+}
+
+static inline size_t vn_sizeof_vkNotifyRingMESA(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+    cmd_size += vn_sizeof_uint32_t(&seqno);
+    cmd_size += vn_sizeof_VkFlags(&flags);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkNotifyRingMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+    vn_encode_uint32_t(enc, &seqno);
+    vn_encode_VkFlags(enc, &flags);
+}
+
+static inline size_t vn_sizeof_vkNotifyRingMESA_reply(uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkNotifyRingMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+    /* skip seqno */
+    /* skip flags */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkNotifyRingMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkNotifyRingMESA_EXT);
+
+    /* skip ring */
+    /* skip seqno */
+    /* skip flags */
+}
+
+static inline size_t vn_sizeof_vkWriteRingExtraMESA(uint64_t ring, size_t offset, uint32_t value)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
+    const VkFlags cmd_flags = 0;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type) + vn_sizeof_VkFlags(&cmd_flags);
+
+    cmd_size += vn_sizeof_uint64_t(&ring);
+    cmd_size += vn_sizeof_size_t(&offset);
+    cmd_size += vn_sizeof_uint32_t(&value);
+
+    return cmd_size;
+}
+
+static inline void vn_encode_vkWriteRingExtraMESA(struct vn_cs_encoder *enc, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
+
+    vn_encode_VkCommandTypeEXT(enc, &cmd_type);
+    vn_encode_VkFlags(enc, &cmd_flags);
+
+    vn_encode_uint64_t(enc, &ring);
+    vn_encode_size_t(enc, &offset);
+    vn_encode_uint32_t(enc, &value);
+}
+
+static inline size_t vn_sizeof_vkWriteRingExtraMESA_reply(uint64_t ring, size_t offset, uint32_t value)
+{
+    const VkCommandTypeEXT cmd_type = VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT;
+    size_t cmd_size = vn_sizeof_VkCommandTypeEXT(&cmd_type);
+
+    /* skip ring */
+    /* skip offset */
+    /* skip value */
+
+    return cmd_size;
+}
+
+static inline void vn_decode_vkWriteRingExtraMESA_reply(struct vn_cs_decoder *dec, uint64_t ring, size_t offset, uint32_t value)
+{
+    VkCommandTypeEXT command_type;
+    vn_decode_VkCommandTypeEXT(dec, &command_type);
+    assert(command_type == VK_COMMAND_TYPE_vkWriteRingExtraMESA_EXT);
+
+    /* skip ring */
+    /* skip offset */
+    /* skip value */
+}
+
+static inline void vn_submit_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, const VkCommandStreamDescriptionMESA* pStream, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSetReplyCommandStreamMESA(pStream);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSetReplyCommandStreamMESA(&submit->command, cmd_flags, pStream);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSetReplyCommandStreamMESA_reply(pStream) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, size_t position, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkSeekReplyCommandStreamMESA(position);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkSeekReplyCommandStreamMESA(&submit->command, cmd_flags, position);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkSeekReplyCommandStreamMESA_reply(position) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkExecuteCommandStreamsMESA(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkExecuteCommandStreamsMESA(&submit->command, cmd_flags, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkExecuteCommandStreamsMESA_reply(streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkCreateRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkCreateRingMESA(ring, pCreateInfo);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkCreateRingMESA(&submit->command, cmd_flags, ring, pCreateInfo);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkCreateRingMESA_reply(ring, pCreateInfo) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkDestroyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkDestroyRingMESA(ring);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkDestroyRingMESA(&submit->command, cmd_flags, ring);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkDestroyRingMESA_reply(ring) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkNotifyRingMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkNotifyRingMESA(ring, seqno, flags);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkNotifyRingMESA(&submit->command, cmd_flags, ring, seqno, flags);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkNotifyRingMESA_reply(ring, seqno, flags) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_submit_vkWriteRingExtraMESA(struct vn_instance *vn_instance, VkCommandFlagsEXT cmd_flags, uint64_t ring, size_t offset, uint32_t value, struct vn_instance_submit_command *submit)
+{
+    uint8_t local_cmd_data[VN_SUBMIT_LOCAL_CMD_SIZE];
+    void *cmd_data = local_cmd_data;
+    size_t cmd_size = vn_sizeof_vkWriteRingExtraMESA(ring, offset, value);
+    if (cmd_size > sizeof(local_cmd_data)) {
+        cmd_data = malloc(cmd_size);
+        if (!cmd_data)
+            cmd_size = 0;
+    }
+
+    submit->command = VN_CS_ENCODER_INITIALIZER(cmd_data, cmd_size);
+    if (cmd_size)
+        vn_encode_vkWriteRingExtraMESA(&submit->command, cmd_flags, ring, offset, value);
+    submit->reply_size = cmd_flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT ? vn_sizeof_vkWriteRingExtraMESA_reply(ring, offset, value) : 0;
+    vn_instance_submit_command(vn_instance, submit);
+
+    if (cmd_data != local_cmd_data)
+        free(cmd_data);
+}
+
+static inline void vn_call_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, pStream, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkSetReplyCommandStreamMESA_reply(&submit.reply, pStream);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkSetReplyCommandStreamMESA(struct vn_instance *vn_instance, const VkCommandStreamDescriptionMESA* pStream)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSetReplyCommandStreamMESA(vn_instance, 0, pStream, &submit);
+}
+
+static inline void vn_call_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, position, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkSeekReplyCommandStreamMESA_reply(&submit.reply, position);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkSeekReplyCommandStreamMESA(struct vn_instance *vn_instance, size_t position)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkSeekReplyCommandStreamMESA(vn_instance, 0, position, &submit);
+}
+
+static inline void vn_call_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkExecuteCommandStreamsMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkExecuteCommandStreamsMESA_reply(&submit.reply, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkExecuteCommandStreamsMESA(struct vn_instance *vn_instance, uint32_t streamCount, const VkCommandStreamDescriptionMESA* pStreams, const size_t* pReplyPositions, uint32_t dependencyCount, const VkCommandStreamDependencyMESA* pDependencies, VkCommandStreamExecutionFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkExecuteCommandStreamsMESA(vn_instance, 0, streamCount, pStreams, pReplyPositions, dependencyCount, pDependencies, flags, &submit);
+}
+
+static inline void vn_call_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, pCreateInfo, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkCreateRingMESA_reply(&submit.reply, ring, pCreateInfo);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkCreateRingMESA(struct vn_instance *vn_instance, uint64_t ring, const VkRingCreateInfoMESA* pCreateInfo)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkCreateRingMESA(vn_instance, 0, ring, pCreateInfo, &submit);
+}
+
+static inline void vn_call_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkDestroyRingMESA_reply(&submit.reply, ring);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkDestroyRingMESA(struct vn_instance *vn_instance, uint64_t ring)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkDestroyRingMESA(vn_instance, 0, ring, &submit);
+}
+
+static inline void vn_call_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkNotifyRingMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, seqno, flags, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkNotifyRingMESA_reply(&submit.reply, ring, seqno, flags);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkNotifyRingMESA(struct vn_instance *vn_instance, uint64_t ring, uint32_t seqno, VkRingNotifyFlagsMESA flags)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkNotifyRingMESA(vn_instance, 0, ring, seqno, flags, &submit);
+}
+
+static inline void vn_call_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWriteRingExtraMESA(vn_instance, VK_COMMAND_GENERATE_REPLY_BIT_EXT, ring, offset, value, &submit);
+    if (submit.reply_bo) {
+        vn_decode_vkWriteRingExtraMESA_reply(&submit.reply, ring, offset, value);
+        vn_renderer_bo_unref(submit.reply_bo);
+    }
+}
+
+static inline void vn_async_vkWriteRingExtraMESA(struct vn_instance *vn_instance, uint64_t ring, size_t offset, uint32_t value)
+{
+    struct vn_instance_submit_command submit;
+    vn_submit_vkWriteRingExtraMESA(vn_instance, 0, ring, offset, value, &submit);
+}
+
+#endif /* VN_PROTOCOL_DRIVER_TRANSPORT_H */

src/virtio/venus-protocol/vn_protocol_driver_types.h

@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-72189394. */
+/* This file is generated by venus-protocol git-2564dba1. */
 
 /*
  * Copyright 2020 Google LLC