vkr: update venus-protocol to 1.3.204

This only updates venus-protocol.  There is no visible functional
difference.

Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Reviewed-by: Ryan Neph <ryanneph@google.com>

src/venus/venus-protocol/vk_platform.h

@@ -2,7 +2,7 @@
 // File: vk_platform.h
 //
 /*
-** Copyright 2014-2021 The Khronos Group Inc.
+** Copyright 2014-2022 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */
@@ -42,7 +42,7 @@ extern "C"
     #define VKAPI_CALL __stdcall
     #define VKAPI_PTR  VKAPI_CALL
 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH < 7
-    #error "Vulkan isn't supported for the 'armeabi' NDK ABI"
+    #error "Vulkan is not supported for the 'armeabi' NDK ABI"
 #elif defined(__ANDROID__) && defined(__ARM_ARCH) && __ARM_ARCH >= 7 && defined(__ARM_32BIT_STATE)
     // On Android 32-bit ARM targets, Vulkan functions use the "hardfloat"
     // calling convention, i.e. float parameters are passed in registers. This

src/venus/venus-protocol/vn_protocol_renderer.h

@@ -1,4 +1,4 @@
-/* This file is generated by venus-protocol git-2cbfe3a2. */
+/* This file is generated by venus-protocol git-0048ccc3. */
 
 /*
  * Copyright 2020 Google LLC
@@ -42,5 +42,6 @@
 #include "vn_protocol_renderer_pipeline_cache.h"
 #include "vn_protocol_renderer_command_pool.h"
 #include "vn_protocol_renderer_command_buffer.h"
+#include "vn_protocol_renderer_private_data_slot.h"
 
 #endif /* VN_PROTOCOL_RENDERER_H */

src/venus/venus-protocol/vn_protocol_renderer_buffer.h

@@ -16,6 +16,29 @@
 
 /* struct VkExternalMemoryBufferCreateInfo chain */
 
+static inline void
+vn_encode_VkExternalMemoryBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalMemoryBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExternalMemoryBufferCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryBufferCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO });
+    vn_encode_VkExternalMemoryBufferCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkExternalMemoryBufferCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -73,6 +96,29 @@ vn_replace_VkExternalMemoryBufferCreateInfo_handle(VkExternalMemoryBufferCreateI
 
 /* struct VkBufferOpaqueCaptureAddressCreateInfo chain */
 
+static inline void
+vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint64_t(enc, &val->opaqueCaptureAddress);
+}
+
+static inline void
+vn_encode_VkBufferOpaqueCaptureAddressCreateInfo(struct vn_cs_encoder *enc, const VkBufferOpaqueCaptureAddressCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO });
+    vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkBufferOpaqueCaptureAddressCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -130,6 +176,61 @@ vn_replace_VkBufferOpaqueCaptureAddressCreateInfo_handle(VkBufferOpaqueCaptureAd
 
 /* struct VkBufferCreateInfo chain */
 
+static inline void
+vn_encode_VkBufferCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExternalMemoryBufferCreateInfo_self(enc, (const VkExternalMemoryBufferCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkBufferCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkBufferOpaqueCaptureAddressCreateInfo_self(enc, (const VkBufferOpaqueCaptureAddressCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkBufferCreateInfo_self(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkDeviceSize(enc, &val->size);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_VkSharingMode(enc, &val->sharingMode);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        vn_encode_array_size(enc, val->queueFamilyIndexCount);
+        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkBufferCreateInfo(struct vn_cs_encoder *enc, const VkBufferCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO });
+    vn_encode_VkBufferCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkBufferCreateInfo_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkBufferCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -515,6 +616,71 @@ vn_replace_VkBufferMemoryRequirementsInfo2_handle(VkBufferMemoryRequirementsInfo
     } while (pnext);
 }
 
+/* struct VkDeviceBufferMemoryRequirements chain */
+
+static inline void *
+vn_decode_VkDeviceBufferMemoryRequirements_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkDeviceBufferMemoryRequirements_self_temp(struct vn_cs_decoder *dec, VkDeviceBufferMemoryRequirements *val)
+{
+    /* skip val->{sType,pNext} */
+    if (vn_decode_simple_pointer(dec)) {
+        val->pCreateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pCreateInfo));
+        if (!val->pCreateInfo) return;
+        vn_decode_VkBufferCreateInfo_temp(dec, (VkBufferCreateInfo *)val->pCreateInfo);
+    } else {
+        val->pCreateInfo = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+}
+
+static inline void
+vn_decode_VkDeviceBufferMemoryRequirements_temp(struct vn_cs_decoder *dec, VkDeviceBufferMemoryRequirements *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkDeviceBufferMemoryRequirements_pnext_temp(dec);
+    vn_decode_VkDeviceBufferMemoryRequirements_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkDeviceBufferMemoryRequirements_handle_self(VkDeviceBufferMemoryRequirements *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    if (val->pCreateInfo)
+        vn_replace_VkBufferCreateInfo_handle((VkBufferCreateInfo *)val->pCreateInfo);
+}
+
+static inline void
+vn_replace_VkDeviceBufferMemoryRequirements_handle(VkDeviceBufferMemoryRequirements *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS:
+            vn_replace_VkDeviceBufferMemoryRequirements_handle_self((VkDeviceBufferMemoryRequirements *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
 /* struct VkBufferDeviceAddressInfo chain */
 
 static inline void
@@ -802,6 +968,45 @@ static inline void vn_encode_vkGetBufferMemoryRequirements2_reply(struct vn_cs_e
         vn_encode_VkMemoryRequirements2(enc, args->pMemoryRequirements);
 }
 
+static inline void vn_decode_vkGetDeviceBufferMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceBufferMemoryRequirements *args)
+{
+    vn_decode_VkDevice_lookup(dec, &args->device);
+    if (vn_decode_simple_pointer(dec)) {
+        args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
+        if (!args->pInfo) return;
+        vn_decode_VkDeviceBufferMemoryRequirements_temp(dec, (VkDeviceBufferMemoryRequirements *)args->pInfo);
+    } else {
+        args->pInfo = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+    if (vn_decode_simple_pointer(dec)) {
+        args->pMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryRequirements));
+        if (!args->pMemoryRequirements) return;
+        vn_decode_VkMemoryRequirements2_partial_temp(dec, args->pMemoryRequirements);
+    } else {
+        args->pMemoryRequirements = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+}
+
+static inline void vn_replace_vkGetDeviceBufferMemoryRequirements_args_handle(struct vn_command_vkGetDeviceBufferMemoryRequirements *args)
+{
+    vn_replace_VkDevice_handle(&args->device);
+    if (args->pInfo)
+        vn_replace_VkDeviceBufferMemoryRequirements_handle((VkDeviceBufferMemoryRequirements *)args->pInfo);
+    /* skip args->pMemoryRequirements */
+}
+
+static inline void vn_encode_vkGetDeviceBufferMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceBufferMemoryRequirements *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT});
+
+    /* skip args->device */
+    /* skip args->pInfo */
+    if (vn_encode_simple_pointer(enc, args->pMemoryRequirements))
+        vn_encode_VkMemoryRequirements2(enc, args->pMemoryRequirements);
+}
+
 static inline void vn_decode_vkGetBufferOpaqueCaptureAddress_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetBufferOpaqueCaptureAddress *args)
 {
     vn_decode_VkDevice_lookup(dec, &args->device);
@@ -1022,6 +1227,31 @@ static inline void vn_dispatch_vkGetBufferMemoryRequirements2(struct vn_dispatch
     vn_cs_decoder_reset_temp_pool(ctx->decoder);
 }
 
+static inline void vn_dispatch_vkGetDeviceBufferMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkGetDeviceBufferMemoryRequirements args;
+
+    if (!ctx->dispatch_vkGetDeviceBufferMemoryRequirements) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkGetDeviceBufferMemoryRequirements_args_temp(ctx->decoder, &args);
+    if (!args.device) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkGetDeviceBufferMemoryRequirements(ctx, &args);
+
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkGetDeviceBufferMemoryRequirements_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
 static inline void vn_dispatch_vkGetBufferOpaqueCaptureAddress(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
 {
     struct vn_command_vkGetBufferOpaqueCaptureAddress args;

src/venus/venus-protocol/vn_protocol_renderer_defines.h

@@ -244,6 +244,80 @@ typedef enum VkCommandTypeEXT {
     VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddressKHR_EXT = 176,
     VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT = 177,
     VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddressKHR_EXT = 177,
+    VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT = 196,
+    VK_COMMAND_TYPE_vkGetPhysicalDeviceToolPropertiesEXT_EXT = 196,
+    VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT = 197,
+    VK_COMMAND_TYPE_vkCreatePrivateDataSlotEXT_EXT = 197,
+    VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT = 198,
+    VK_COMMAND_TYPE_vkDestroyPrivateDataSlotEXT_EXT = 198,
+    VK_COMMAND_TYPE_vkSetPrivateData_EXT = 199,
+    VK_COMMAND_TYPE_vkSetPrivateDataEXT_EXT = 199,
+    VK_COMMAND_TYPE_vkGetPrivateData_EXT = 200,
+    VK_COMMAND_TYPE_vkGetPrivateDataEXT_EXT = 200,
+    VK_COMMAND_TYPE_vkCmdSetEvent2_EXT = 201,
+    VK_COMMAND_TYPE_vkCmdSetEvent2KHR_EXT = 201,
+    VK_COMMAND_TYPE_vkCmdResetEvent2_EXT = 202,
+    VK_COMMAND_TYPE_vkCmdResetEvent2KHR_EXT = 202,
+    VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT = 203,
+    VK_COMMAND_TYPE_vkCmdWaitEvents2KHR_EXT = 203,
+    VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT = 204,
+    VK_COMMAND_TYPE_vkCmdPipelineBarrier2KHR_EXT = 204,
+    VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT = 205,
+    VK_COMMAND_TYPE_vkCmdWriteTimestamp2KHR_EXT = 205,
+    VK_COMMAND_TYPE_vkQueueSubmit2_EXT = 206,
+    VK_COMMAND_TYPE_vkQueueSubmit2KHR_EXT = 206,
+    VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT = 207,
+    VK_COMMAND_TYPE_vkCmdCopyBuffer2KHR_EXT = 207,
+    VK_COMMAND_TYPE_vkCmdCopyImage2_EXT = 208,
+    VK_COMMAND_TYPE_vkCmdCopyImage2KHR_EXT = 208,
+    VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT = 209,
+    VK_COMMAND_TYPE_vkCmdCopyBufferToImage2KHR_EXT = 209,
+    VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT = 210,
+    VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2KHR_EXT = 210,
+    VK_COMMAND_TYPE_vkCmdBlitImage2_EXT = 211,
+    VK_COMMAND_TYPE_vkCmdBlitImage2KHR_EXT = 211,
+    VK_COMMAND_TYPE_vkCmdResolveImage2_EXT = 212,
+    VK_COMMAND_TYPE_vkCmdResolveImage2KHR_EXT = 212,
+    VK_COMMAND_TYPE_vkCmdBeginRendering_EXT = 213,
+    VK_COMMAND_TYPE_vkCmdBeginRenderingKHR_EXT = 213,
+    VK_COMMAND_TYPE_vkCmdEndRendering_EXT = 214,
+    VK_COMMAND_TYPE_vkCmdEndRenderingKHR_EXT = 214,
+    VK_COMMAND_TYPE_vkCmdSetCullMode_EXT = 215,
+    VK_COMMAND_TYPE_vkCmdSetCullModeEXT_EXT = 215,
+    VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT = 216,
+    VK_COMMAND_TYPE_vkCmdSetFrontFaceEXT_EXT = 216,
+    VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT = 217,
+    VK_COMMAND_TYPE_vkCmdSetPrimitiveTopologyEXT_EXT = 217,
+    VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT = 218,
+    VK_COMMAND_TYPE_vkCmdSetViewportWithCountEXT_EXT = 218,
+    VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT = 219,
+    VK_COMMAND_TYPE_vkCmdSetScissorWithCountEXT_EXT = 219,
+    VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT = 220,
+    VK_COMMAND_TYPE_vkCmdBindVertexBuffers2EXT_EXT = 220,
+    VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT = 221,
+    VK_COMMAND_TYPE_vkCmdSetDepthTestEnableEXT_EXT = 221,
+    VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT = 222,
+    VK_COMMAND_TYPE_vkCmdSetDepthWriteEnableEXT_EXT = 222,
+    VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT = 223,
+    VK_COMMAND_TYPE_vkCmdSetDepthCompareOpEXT_EXT = 223,
+    VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT = 224,
+    VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnableEXT_EXT = 224,
+    VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT = 225,
+    VK_COMMAND_TYPE_vkCmdSetStencilTestEnableEXT_EXT = 225,
+    VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT = 226,
+    VK_COMMAND_TYPE_vkCmdSetStencilOpEXT_EXT = 226,
+    VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT = 227,
+    VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnableEXT_EXT = 227,
+    VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT = 228,
+    VK_COMMAND_TYPE_vkCmdSetDepthBiasEnableEXT_EXT = 228,
+    VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT = 229,
+    VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnableEXT_EXT = 229,
+    VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT = 230,
+    VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirementsKHR_EXT = 230,
+    VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT = 231,
+    VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirementsKHR_EXT = 231,
+    VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT = 232,
+    VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirementsKHR_EXT = 232,
     VK_COMMAND_TYPE_vkCmdBindTransformFeedbackBuffersEXT_EXT = 181,
     VK_COMMAND_TYPE_vkCmdBeginTransformFeedbackEXT_EXT = 182,
     VK_COMMAND_TYPE_vkCmdEndTransformFeedbackEXT_EXT = 183,
@@ -253,6 +327,8 @@ typedef enum VkCommandTypeEXT {
     VK_COMMAND_TYPE_vkGetMemoryFdKHR_EXT = 193,
     VK_COMMAND_TYPE_vkGetMemoryFdPropertiesKHR_EXT = 194,
     VK_COMMAND_TYPE_vkGetImageDrmFormatModifierPropertiesEXT_EXT = 187,
+    VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT = 233,
+    VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT = 234,
     VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT = 178,
     VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT = 179,
     VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT = 180,
@@ -1558,6 +1634,25 @@ struct vn_command_vkGetImageSparseMemoryRequirements2 {
     VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
 };
 
+struct vn_command_vkGetDeviceBufferMemoryRequirements {
+    VkDevice device;
+    const VkDeviceBufferMemoryRequirements* pInfo;
+    VkMemoryRequirements2* pMemoryRequirements;
+};
+
+struct vn_command_vkGetDeviceImageMemoryRequirements {
+    VkDevice device;
+    const VkDeviceImageMemoryRequirements* pInfo;
+    VkMemoryRequirements2* pMemoryRequirements;
+};
+
+struct vn_command_vkGetDeviceImageSparseMemoryRequirements {
+    VkDevice device;
+    const VkDeviceImageMemoryRequirements* pInfo;
+    uint32_t* pSparseMemoryRequirementCount;
+    VkSparseImageMemoryRequirements2* pSparseMemoryRequirements;
+};
+
 struct vn_command_vkCreateSamplerYcbcrConversion {
     VkDevice device;
     const VkSamplerYcbcrConversionCreateInfo* pCreateInfo;
@@ -1733,6 +1828,222 @@ struct vn_command_vkGetDeviceMemoryOpaqueCaptureAddress {
     uint64_t ret;
 };
 
+struct vn_command_vkGetPhysicalDeviceToolProperties {
+    VkPhysicalDevice physicalDevice;
+    uint32_t* pToolCount;
+    VkPhysicalDeviceToolProperties* pToolProperties;
+
+    VkResult ret;
+};
+
+struct vn_command_vkCmdSetCullMode {
+    VkCommandBuffer commandBuffer;
+    VkCullModeFlags cullMode;
+};
+
+struct vn_command_vkCmdSetFrontFace {
+    VkCommandBuffer commandBuffer;
+    VkFrontFace frontFace;
+};
+
+struct vn_command_vkCmdSetPrimitiveTopology {
+    VkCommandBuffer commandBuffer;
+    VkPrimitiveTopology primitiveTopology;
+};
+
+struct vn_command_vkCmdSetViewportWithCount {
+    VkCommandBuffer commandBuffer;
+    uint32_t viewportCount;
+    const VkViewport* pViewports;
+};
+
+struct vn_command_vkCmdSetScissorWithCount {
+    VkCommandBuffer commandBuffer;
+    uint32_t scissorCount;
+    const VkRect2D* pScissors;
+};
+
+struct vn_command_vkCmdBindVertexBuffers2 {
+    VkCommandBuffer commandBuffer;
+    uint32_t firstBinding;
+    uint32_t bindingCount;
+    const VkBuffer* pBuffers;
+    const VkDeviceSize* pOffsets;
+    const VkDeviceSize* pSizes;
+    const VkDeviceSize* pStrides;
+};
+
+struct vn_command_vkCmdSetDepthTestEnable {
+    VkCommandBuffer commandBuffer;
+    VkBool32 depthTestEnable;
+};
+
+struct vn_command_vkCmdSetDepthWriteEnable {
+    VkCommandBuffer commandBuffer;
+    VkBool32 depthWriteEnable;
+};
+
+struct vn_command_vkCmdSetDepthCompareOp {
+    VkCommandBuffer commandBuffer;
+    VkCompareOp depthCompareOp;
+};
+
+struct vn_command_vkCmdSetDepthBoundsTestEnable {
+    VkCommandBuffer commandBuffer;
+    VkBool32 depthBoundsTestEnable;
+};
+
+struct vn_command_vkCmdSetStencilTestEnable {
+    VkCommandBuffer commandBuffer;
+    VkBool32 stencilTestEnable;
+};
+
+struct vn_command_vkCmdSetStencilOp {
+    VkCommandBuffer commandBuffer;
+    VkStencilFaceFlags faceMask;
+    VkStencilOp failOp;
+    VkStencilOp passOp;
+    VkStencilOp depthFailOp;
+    VkCompareOp compareOp;
+};
+
+struct vn_command_vkCmdSetPatchControlPointsEXT {
+    VkCommandBuffer commandBuffer;
+    uint32_t patchControlPoints;
+};
+
+struct vn_command_vkCmdSetRasterizerDiscardEnable {
+    VkCommandBuffer commandBuffer;
+    VkBool32 rasterizerDiscardEnable;
+};
+
+struct vn_command_vkCmdSetDepthBiasEnable {
+    VkCommandBuffer commandBuffer;
+    VkBool32 depthBiasEnable;
+};
+
+struct vn_command_vkCmdSetLogicOpEXT {
+    VkCommandBuffer commandBuffer;
+    VkLogicOp logicOp;
+};
+
+struct vn_command_vkCmdSetPrimitiveRestartEnable {
+    VkCommandBuffer commandBuffer;
+    VkBool32 primitiveRestartEnable;
+};
+
+struct vn_command_vkCreatePrivateDataSlot {
+    VkDevice device;
+    const VkPrivateDataSlotCreateInfo* pCreateInfo;
+    const VkAllocationCallbacks* pAllocator;
+    VkPrivateDataSlot* pPrivateDataSlot;
+
+    VkResult ret;
+};
+
+struct vn_command_vkDestroyPrivateDataSlot {
+    VkDevice device;
+    VkPrivateDataSlot privateDataSlot;
+    const VkAllocationCallbacks* pAllocator;
+};
+
+struct vn_command_vkSetPrivateData {
+    VkDevice device;
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    VkPrivateDataSlot privateDataSlot;
+    uint64_t data;
+
+    VkResult ret;
+};
+
+struct vn_command_vkGetPrivateData {
+    VkDevice device;
+    VkObjectType objectType;
+    uint64_t objectHandle;
+    VkPrivateDataSlot privateDataSlot;
+    uint64_t* pData;
+};
+
+struct vn_command_vkCmdCopyBuffer2 {
+    VkCommandBuffer commandBuffer;
+    const VkCopyBufferInfo2* pCopyBufferInfo;
+};
+
+struct vn_command_vkCmdCopyImage2 {
+    VkCommandBuffer commandBuffer;
+    const VkCopyImageInfo2* pCopyImageInfo;
+};
+
+struct vn_command_vkCmdBlitImage2 {
+    VkCommandBuffer commandBuffer;
+    const VkBlitImageInfo2* pBlitImageInfo;
+};
+
+struct vn_command_vkCmdCopyBufferToImage2 {
+    VkCommandBuffer commandBuffer;
+    const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo;
+};
+
+struct vn_command_vkCmdCopyImageToBuffer2 {
+    VkCommandBuffer commandBuffer;
+    const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo;
+};
+
+struct vn_command_vkCmdResolveImage2 {
+    VkCommandBuffer commandBuffer;
+    const VkResolveImageInfo2* pResolveImageInfo;
+};
+
+struct vn_command_vkCmdSetEvent2 {
+    VkCommandBuffer commandBuffer;
+    VkEvent event;
+    const VkDependencyInfo* pDependencyInfo;
+};
+
+struct vn_command_vkCmdResetEvent2 {
+    VkCommandBuffer commandBuffer;
+    VkEvent event;
+    VkPipelineStageFlags2 stageMask;
+};
+
+struct vn_command_vkCmdWaitEvents2 {
+    VkCommandBuffer commandBuffer;
+    uint32_t eventCount;
+    const VkEvent* pEvents;
+    const VkDependencyInfo* pDependencyInfos;
+};
+
+struct vn_command_vkCmdPipelineBarrier2 {
+    VkCommandBuffer commandBuffer;
+    const VkDependencyInfo* pDependencyInfo;
+};
+
+struct vn_command_vkQueueSubmit2 {
+    VkQueue queue;
+    uint32_t submitCount;
+    const VkSubmitInfo2* pSubmits;
+    VkFence fence;
+
+    VkResult ret;
+};
+
+struct vn_command_vkCmdWriteTimestamp2 {
+    VkCommandBuffer commandBuffer;
+    VkPipelineStageFlags2 stage;
+    VkQueryPool queryPool;
+    uint32_t query;
+};
+
+struct vn_command_vkCmdBeginRendering {
+    VkCommandBuffer commandBuffer;
+    const VkRenderingInfo* pRenderingInfo;
+};
+
+struct vn_command_vkCmdEndRendering {
+    VkCommandBuffer commandBuffer;
+};
+
 struct vn_command_vkSetReplyCommandStreamMESA {
     const VkCommandStreamDescriptionMESA* pStream;
 };
@@ -1955,6 +2266,9 @@ struct vn_dispatch_context {
     void (*dispatch_vkGetBufferMemoryRequirements2)(struct vn_dispatch_context *ctx, struct vn_command_vkGetBufferMemoryRequirements2 *args);
     void (*dispatch_vkGetImageMemoryRequirements2)(struct vn_dispatch_context *ctx, struct vn_command_vkGetImageMemoryRequirements2 *args);
     void (*dispatch_vkGetImageSparseMemoryRequirements2)(struct vn_dispatch_context *ctx, struct vn_command_vkGetImageSparseMemoryRequirements2 *args);
+    void (*dispatch_vkGetDeviceBufferMemoryRequirements)(struct vn_dispatch_context *ctx, struct vn_command_vkGetDeviceBufferMemoryRequirements *args);
+    void (*dispatch_vkGetDeviceImageMemoryRequirements)(struct vn_dispatch_context *ctx, struct vn_command_vkGetDeviceImageMemoryRequirements *args);
+    void (*dispatch_vkGetDeviceImageSparseMemoryRequirements)(struct vn_dispatch_context *ctx, struct vn_command_vkGetDeviceImageSparseMemoryRequirements *args);
     void (*dispatch_vkCreateSamplerYcbcrConversion)(struct vn_dispatch_context *ctx, struct vn_command_vkCreateSamplerYcbcrConversion *args);
     void (*dispatch_vkDestroySamplerYcbcrConversion)(struct vn_dispatch_context *ctx, struct vn_command_vkDestroySamplerYcbcrConversion *args);
     void (*dispatch_vkGetDeviceQueue2)(struct vn_dispatch_context *ctx, struct vn_command_vkGetDeviceQueue2 *args);
@@ -1978,6 +2292,42 @@ struct vn_dispatch_context {
     void (*dispatch_vkGetBufferOpaqueCaptureAddress)(struct vn_dispatch_context *ctx, struct vn_command_vkGetBufferOpaqueCaptureAddress *args);
     void (*dispatch_vkGetBufferDeviceAddress)(struct vn_dispatch_context *ctx, struct vn_command_vkGetBufferDeviceAddress *args);
     void (*dispatch_vkGetDeviceMemoryOpaqueCaptureAddress)(struct vn_dispatch_context *ctx, struct vn_command_vkGetDeviceMemoryOpaqueCaptureAddress *args);
+    void (*dispatch_vkGetPhysicalDeviceToolProperties)(struct vn_dispatch_context *ctx, struct vn_command_vkGetPhysicalDeviceToolProperties *args);
+    void (*dispatch_vkCmdSetCullMode)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetCullMode *args);
+    void (*dispatch_vkCmdSetFrontFace)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetFrontFace *args);
+    void (*dispatch_vkCmdSetPrimitiveTopology)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetPrimitiveTopology *args);
+    void (*dispatch_vkCmdSetViewportWithCount)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetViewportWithCount *args);
+    void (*dispatch_vkCmdSetScissorWithCount)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetScissorWithCount *args);
+    void (*dispatch_vkCmdBindVertexBuffers2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdBindVertexBuffers2 *args);
+    void (*dispatch_vkCmdSetDepthTestEnable)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetDepthTestEnable *args);
+    void (*dispatch_vkCmdSetDepthWriteEnable)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetDepthWriteEnable *args);
+    void (*dispatch_vkCmdSetDepthCompareOp)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetDepthCompareOp *args);
+    void (*dispatch_vkCmdSetDepthBoundsTestEnable)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetDepthBoundsTestEnable *args);
+    void (*dispatch_vkCmdSetStencilTestEnable)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetStencilTestEnable *args);
+    void (*dispatch_vkCmdSetStencilOp)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetStencilOp *args);
+    void (*dispatch_vkCmdSetPatchControlPointsEXT)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetPatchControlPointsEXT *args);
+    void (*dispatch_vkCmdSetRasterizerDiscardEnable)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetRasterizerDiscardEnable *args);
+    void (*dispatch_vkCmdSetDepthBiasEnable)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetDepthBiasEnable *args);
+    void (*dispatch_vkCmdSetLogicOpEXT)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetLogicOpEXT *args);
+    void (*dispatch_vkCmdSetPrimitiveRestartEnable)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetPrimitiveRestartEnable *args);
+    void (*dispatch_vkCreatePrivateDataSlot)(struct vn_dispatch_context *ctx, struct vn_command_vkCreatePrivateDataSlot *args);
+    void (*dispatch_vkDestroyPrivateDataSlot)(struct vn_dispatch_context *ctx, struct vn_command_vkDestroyPrivateDataSlot *args);
+    void (*dispatch_vkSetPrivateData)(struct vn_dispatch_context *ctx, struct vn_command_vkSetPrivateData *args);
+    void (*dispatch_vkGetPrivateData)(struct vn_dispatch_context *ctx, struct vn_command_vkGetPrivateData *args);
+    void (*dispatch_vkCmdCopyBuffer2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdCopyBuffer2 *args);
+    void (*dispatch_vkCmdCopyImage2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdCopyImage2 *args);
+    void (*dispatch_vkCmdBlitImage2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdBlitImage2 *args);
+    void (*dispatch_vkCmdCopyBufferToImage2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdCopyBufferToImage2 *args);
+    void (*dispatch_vkCmdCopyImageToBuffer2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdCopyImageToBuffer2 *args);
+    void (*dispatch_vkCmdResolveImage2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdResolveImage2 *args);
+    void (*dispatch_vkCmdSetEvent2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdSetEvent2 *args);
+    void (*dispatch_vkCmdResetEvent2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdResetEvent2 *args);
+    void (*dispatch_vkCmdWaitEvents2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdWaitEvents2 *args);
+    void (*dispatch_vkCmdPipelineBarrier2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdPipelineBarrier2 *args);
+    void (*dispatch_vkQueueSubmit2)(struct vn_dispatch_context *ctx, struct vn_command_vkQueueSubmit2 *args);
+    void (*dispatch_vkCmdWriteTimestamp2)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdWriteTimestamp2 *args);
+    void (*dispatch_vkCmdBeginRendering)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdBeginRendering *args);
+    void (*dispatch_vkCmdEndRendering)(struct vn_dispatch_context *ctx, struct vn_command_vkCmdEndRendering *args);
     void (*dispatch_vkSetReplyCommandStreamMESA)(struct vn_dispatch_context *ctx, struct vn_command_vkSetReplyCommandStreamMESA *args);
     void (*dispatch_vkSeekReplyCommandStreamMESA)(struct vn_dispatch_context *ctx, struct vn_command_vkSeekReplyCommandStreamMESA *args);
     void (*dispatch_vkExecuteCommandStreamsMESA)(struct vn_dispatch_context *ctx, struct vn_command_vkExecuteCommandStreamsMESA *args);

src/venus/venus-protocol/vn_protocol_renderer_descriptor_pool.h

@@ -30,10 +30,10 @@ vn_replace_VkDescriptorPoolSize_handle(VkDescriptorPoolSize *val)
     /* skip val->descriptorCount */
 }
 
-/* struct VkDescriptorPoolCreateInfo chain */
+/* struct VkDescriptorPoolInlineUniformBlockCreateInfo chain */
 
 static inline void *
-vn_decode_VkDescriptorPoolCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+vn_decode_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
     /* no known/supported struct */
     if (vn_decode_simple_pointer(dec))
@@ -41,6 +41,83 @@ vn_decode_VkDescriptorPoolCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
     return NULL;
 }
 
+static inline void
+vn_decode_VkDescriptorPoolInlineUniformBlockCreateInfo_self_temp(struct vn_cs_decoder *dec, VkDescriptorPoolInlineUniformBlockCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->maxInlineUniformBlockBindings);
+}
+
+static inline void
+vn_decode_VkDescriptorPoolInlineUniformBlockCreateInfo_temp(struct vn_cs_decoder *dec, VkDescriptorPoolInlineUniformBlockCreateInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkDescriptorPoolInlineUniformBlockCreateInfo_pnext_temp(dec);
+    vn_decode_VkDescriptorPoolInlineUniformBlockCreateInfo_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkDescriptorPoolInlineUniformBlockCreateInfo_handle_self(VkDescriptorPoolInlineUniformBlockCreateInfo *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    /* skip val->maxInlineUniformBlockBindings */
+}
+
+static inline void
+vn_replace_VkDescriptorPoolInlineUniformBlockCreateInfo_handle(VkDescriptorPoolInlineUniformBlockCreateInfo *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+            vn_replace_VkDescriptorPoolInlineUniformBlockCreateInfo_handle_self((VkDescriptorPoolInlineUniformBlockCreateInfo *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+/* struct VkDescriptorPoolCreateInfo chain */
+
+static inline void *
+vn_decode_VkDescriptorPoolCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+{
+    VkBaseOutStructure *pnext;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return NULL;
+
+    vn_decode_VkStructureType(dec, &stype);
+    switch ((int32_t)stype) {
+    case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+        pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo));
+        if (pnext) {
+            pnext->sType = stype;
+            pnext->pNext = vn_decode_VkDescriptorPoolCreateInfo_pnext_temp(dec);
+            vn_decode_VkDescriptorPoolInlineUniformBlockCreateInfo_self_temp(dec, (VkDescriptorPoolInlineUniformBlockCreateInfo *)pnext);
+        }
+        break;
+    default:
+        /* unexpected struct */
+        pnext = NULL;
+        vn_cs_decoder_set_fatal(dec);
+        break;
+    }
+
+    return pnext;
+}
+
 static inline void
 vn_decode_VkDescriptorPoolCreateInfo_self_temp(struct vn_cs_decoder *dec, VkDescriptorPoolCreateInfo *val)
 {
@@ -97,6 +174,9 @@ vn_replace_VkDescriptorPoolCreateInfo_handle(VkDescriptorPoolCreateInfo *val)
         case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO:
             vn_replace_VkDescriptorPoolCreateInfo_handle_self((VkDescriptorPoolCreateInfo *)pnext);
             break;
+        case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO:
+            vn_replace_VkDescriptorPoolInlineUniformBlockCreateInfo_handle_self((VkDescriptorPoolInlineUniformBlockCreateInfo *)pnext);
+            break;
         default:
             /* ignore unknown/unsupported struct */
             break;

src/venus/venus-protocol/vn_protocol_renderer_descriptor_set.h

@@ -219,10 +219,10 @@ vn_replace_VkDescriptorBufferInfo_handle(VkDescriptorBufferInfo *val)
     /* skip val->range */
 }
 
-/* struct VkWriteDescriptorSet chain */
+/* struct VkWriteDescriptorSetInlineUniformBlock chain */
 
 static inline void *
-vn_decode_VkWriteDescriptorSet_pnext_temp(struct vn_cs_decoder *dec)
+vn_decode_VkWriteDescriptorSetInlineUniformBlock_pnext_temp(struct vn_cs_decoder *dec)
 {
     /* no known/supported struct */
     if (vn_decode_simple_pointer(dec))
@@ -230,6 +230,93 @@ vn_decode_VkWriteDescriptorSet_pnext_temp(struct vn_cs_decoder *dec)
     return NULL;
 }
 
+static inline void
+vn_decode_VkWriteDescriptorSetInlineUniformBlock_self_temp(struct vn_cs_decoder *dec, VkWriteDescriptorSetInlineUniformBlock *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->dataSize);
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, val->dataSize);
+        val->pData = vn_cs_decoder_alloc_temp(dec, array_size);
+        if (!val->pData) return;
+        vn_decode_blob_array(dec, (void *)val->pData, array_size);
+    } else {
+        vn_decode_array_size(dec, val->dataSize);
+        val->pData = NULL;
+    }
+}
+
+static inline void
+vn_decode_VkWriteDescriptorSetInlineUniformBlock_temp(struct vn_cs_decoder *dec, VkWriteDescriptorSetInlineUniformBlock *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkWriteDescriptorSetInlineUniformBlock_pnext_temp(dec);
+    vn_decode_VkWriteDescriptorSetInlineUniformBlock_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkWriteDescriptorSetInlineUniformBlock_handle_self(VkWriteDescriptorSetInlineUniformBlock *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    /* skip val->dataSize */
+    /* skip val->pData */
+}
+
+static inline void
+vn_replace_VkWriteDescriptorSetInlineUniformBlock_handle(VkWriteDescriptorSetInlineUniformBlock *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+            vn_replace_VkWriteDescriptorSetInlineUniformBlock_handle_self((VkWriteDescriptorSetInlineUniformBlock *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+/* struct VkWriteDescriptorSet chain */
+
+static inline void *
+vn_decode_VkWriteDescriptorSet_pnext_temp(struct vn_cs_decoder *dec)
+{
+    VkBaseOutStructure *pnext;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return NULL;
+
+    vn_decode_VkStructureType(dec, &stype);
+    switch ((int32_t)stype) {
+    case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+        pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkWriteDescriptorSetInlineUniformBlock));
+        if (pnext) {
+            pnext->sType = stype;
+            pnext->pNext = vn_decode_VkWriteDescriptorSet_pnext_temp(dec);
+            vn_decode_VkWriteDescriptorSetInlineUniformBlock_self_temp(dec, (VkWriteDescriptorSetInlineUniformBlock *)pnext);
+        }
+        break;
+    default:
+        /* unexpected struct */
+        pnext = NULL;
+        vn_cs_decoder_set_fatal(dec);
+        break;
+    }
+
+    return pnext;
+}
+
 static inline void
 vn_decode_VkWriteDescriptorSet_self_temp(struct vn_cs_decoder *dec, VkWriteDescriptorSet *val)
 {
@@ -318,6 +405,9 @@ vn_replace_VkWriteDescriptorSet_handle(VkWriteDescriptorSet *val)
         case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET:
             vn_replace_VkWriteDescriptorSet_handle_self((VkWriteDescriptorSet *)pnext);
             break;
+        case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK:
+            vn_replace_VkWriteDescriptorSetInlineUniformBlock_handle_self((VkWriteDescriptorSetInlineUniformBlock *)pnext);
+            break;
         default:
             /* ignore unknown/unsupported struct */
             break;

src/venus/venus-protocol/vn_protocol_renderer_dispatches.h

@@ -38,6 +38,7 @@
 #include "vn_protocol_renderer_pipeline_cache.h"
 #include "vn_protocol_renderer_command_pool.h"
 #include "vn_protocol_renderer_command_buffer.h"
+#include "vn_protocol_renderer_private_data_slot.h"
 
 static inline const char *vn_dispatch_command_name(VkCommandTypeEXT type)
 {
@@ -200,6 +201,9 @@ static inline const char *vn_dispatch_command_name(VkCommandTypeEXT type)
     case VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT: return "vkGetBufferMemoryRequirements2";
     case VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT: return "vkGetImageMemoryRequirements2";
     case VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT: return "vkGetImageSparseMemoryRequirements2";
+    case VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT: return "vkGetDeviceBufferMemoryRequirements";
+    case VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT: return "vkGetDeviceImageMemoryRequirements";
+    case VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT: return "vkGetDeviceImageSparseMemoryRequirements";
     case VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT: return "vkCreateSamplerYcbcrConversion";
     case VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT: return "vkDestroySamplerYcbcrConversion";
     case VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT: return "vkGetDeviceQueue2";
@@ -223,6 +227,42 @@ static inline const char *vn_dispatch_command_name(VkCommandTypeEXT type)
     case VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT: return "vkGetBufferOpaqueCaptureAddress";
     case VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT: return "vkGetBufferDeviceAddress";
     case VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT: return "vkGetDeviceMemoryOpaqueCaptureAddress";
+    case VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT: return "vkGetPhysicalDeviceToolProperties";
+    case VK_COMMAND_TYPE_vkCmdSetCullMode_EXT: return "vkCmdSetCullMode";
+    case VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT: return "vkCmdSetFrontFace";
+    case VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT: return "vkCmdSetPrimitiveTopology";
+    case VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT: return "vkCmdSetViewportWithCount";
+    case VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT: return "vkCmdSetScissorWithCount";
+    case VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT: return "vkCmdBindVertexBuffers2";
+    case VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT: return "vkCmdSetDepthTestEnable";
+    case VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT: return "vkCmdSetDepthWriteEnable";
+    case VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT: return "vkCmdSetDepthCompareOp";
+    case VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT: return "vkCmdSetDepthBoundsTestEnable";
+    case VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT: return "vkCmdSetStencilTestEnable";
+    case VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT: return "vkCmdSetStencilOp";
+    case VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT: return "vkCmdSetPatchControlPointsEXT";
+    case VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT: return "vkCmdSetRasterizerDiscardEnable";
+    case VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT: return "vkCmdSetDepthBiasEnable";
+    case VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT: return "vkCmdSetLogicOpEXT";
+    case VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT: return "vkCmdSetPrimitiveRestartEnable";
+    case VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT: return "vkCreatePrivateDataSlot";
+    case VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT: return "vkDestroyPrivateDataSlot";
+    case VK_COMMAND_TYPE_vkSetPrivateData_EXT: return "vkSetPrivateData";
+    case VK_COMMAND_TYPE_vkGetPrivateData_EXT: return "vkGetPrivateData";
+    case VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT: return "vkCmdCopyBuffer2";
+    case VK_COMMAND_TYPE_vkCmdCopyImage2_EXT: return "vkCmdCopyImage2";
+    case VK_COMMAND_TYPE_vkCmdBlitImage2_EXT: return "vkCmdBlitImage2";
+    case VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT: return "vkCmdCopyBufferToImage2";
+    case VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT: return "vkCmdCopyImageToBuffer2";
+    case VK_COMMAND_TYPE_vkCmdResolveImage2_EXT: return "vkCmdResolveImage2";
+    case VK_COMMAND_TYPE_vkCmdSetEvent2_EXT: return "vkCmdSetEvent2";
+    case VK_COMMAND_TYPE_vkCmdResetEvent2_EXT: return "vkCmdResetEvent2";
+    case VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT: return "vkCmdWaitEvents2";
+    case VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT: return "vkCmdPipelineBarrier2";
+    case VK_COMMAND_TYPE_vkQueueSubmit2_EXT: return "vkQueueSubmit2";
+    case VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT: return "vkCmdWriteTimestamp2";
+    case VK_COMMAND_TYPE_vkCmdBeginRendering_EXT: return "vkCmdBeginRendering";
+    case VK_COMMAND_TYPE_vkCmdEndRendering_EXT: return "vkCmdEndRendering";
     case VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT: return "vkSetReplyCommandStreamMESA";
     case VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT: return "vkSeekReplyCommandStreamMESA";
     case VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT: return "vkExecuteCommandStreamsMESA";
@@ -242,7 +282,7 @@ static inline const char *vn_dispatch_command_name(VkCommandTypeEXT type)
     }
 }
 
-static void (*const vn_dispatch_table[196])(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) = {
+static void (*const vn_dispatch_table[235])(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags) = {
     [VK_COMMAND_TYPE_vkCreateInstance_EXT] = vn_dispatch_vkCreateInstance,
     [VK_COMMAND_TYPE_vkDestroyInstance_EXT] = vn_dispatch_vkDestroyInstance,
     [VK_COMMAND_TYPE_vkEnumeratePhysicalDevices_EXT] = vn_dispatch_vkEnumeratePhysicalDevices,
@@ -401,6 +441,9 @@ static void (*const vn_dispatch_table[196])(struct vn_dispatch_context *ctx, VkC
     [VK_COMMAND_TYPE_vkGetBufferMemoryRequirements2_EXT] = vn_dispatch_vkGetBufferMemoryRequirements2,
     [VK_COMMAND_TYPE_vkGetImageMemoryRequirements2_EXT] = vn_dispatch_vkGetImageMemoryRequirements2,
     [VK_COMMAND_TYPE_vkGetImageSparseMemoryRequirements2_EXT] = vn_dispatch_vkGetImageSparseMemoryRequirements2,
+    [VK_COMMAND_TYPE_vkGetDeviceBufferMemoryRequirements_EXT] = vn_dispatch_vkGetDeviceBufferMemoryRequirements,
+    [VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT] = vn_dispatch_vkGetDeviceImageMemoryRequirements,
+    [VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT] = vn_dispatch_vkGetDeviceImageSparseMemoryRequirements,
     [VK_COMMAND_TYPE_vkCreateSamplerYcbcrConversion_EXT] = vn_dispatch_vkCreateSamplerYcbcrConversion,
     [VK_COMMAND_TYPE_vkDestroySamplerYcbcrConversion_EXT] = vn_dispatch_vkDestroySamplerYcbcrConversion,
     [VK_COMMAND_TYPE_vkGetDeviceQueue2_EXT] = vn_dispatch_vkGetDeviceQueue2,
@@ -424,6 +467,42 @@ static void (*const vn_dispatch_table[196])(struct vn_dispatch_context *ctx, VkC
     [VK_COMMAND_TYPE_vkGetBufferOpaqueCaptureAddress_EXT] = vn_dispatch_vkGetBufferOpaqueCaptureAddress,
     [VK_COMMAND_TYPE_vkGetBufferDeviceAddress_EXT] = vn_dispatch_vkGetBufferDeviceAddress,
     [VK_COMMAND_TYPE_vkGetDeviceMemoryOpaqueCaptureAddress_EXT] = vn_dispatch_vkGetDeviceMemoryOpaqueCaptureAddress,
+    [VK_COMMAND_TYPE_vkGetPhysicalDeviceToolProperties_EXT] = vn_dispatch_vkGetPhysicalDeviceToolProperties,
+    [VK_COMMAND_TYPE_vkCmdSetCullMode_EXT] = vn_dispatch_vkCmdSetCullMode,
+    [VK_COMMAND_TYPE_vkCmdSetFrontFace_EXT] = vn_dispatch_vkCmdSetFrontFace,
+    [VK_COMMAND_TYPE_vkCmdSetPrimitiveTopology_EXT] = vn_dispatch_vkCmdSetPrimitiveTopology,
+    [VK_COMMAND_TYPE_vkCmdSetViewportWithCount_EXT] = vn_dispatch_vkCmdSetViewportWithCount,
+    [VK_COMMAND_TYPE_vkCmdSetScissorWithCount_EXT] = vn_dispatch_vkCmdSetScissorWithCount,
+    [VK_COMMAND_TYPE_vkCmdBindVertexBuffers2_EXT] = vn_dispatch_vkCmdBindVertexBuffers2,
+    [VK_COMMAND_TYPE_vkCmdSetDepthTestEnable_EXT] = vn_dispatch_vkCmdSetDepthTestEnable,
+    [VK_COMMAND_TYPE_vkCmdSetDepthWriteEnable_EXT] = vn_dispatch_vkCmdSetDepthWriteEnable,
+    [VK_COMMAND_TYPE_vkCmdSetDepthCompareOp_EXT] = vn_dispatch_vkCmdSetDepthCompareOp,
+    [VK_COMMAND_TYPE_vkCmdSetDepthBoundsTestEnable_EXT] = vn_dispatch_vkCmdSetDepthBoundsTestEnable,
+    [VK_COMMAND_TYPE_vkCmdSetStencilTestEnable_EXT] = vn_dispatch_vkCmdSetStencilTestEnable,
+    [VK_COMMAND_TYPE_vkCmdSetStencilOp_EXT] = vn_dispatch_vkCmdSetStencilOp,
+    [VK_COMMAND_TYPE_vkCmdSetPatchControlPointsEXT_EXT] = vn_dispatch_vkCmdSetPatchControlPointsEXT,
+    [VK_COMMAND_TYPE_vkCmdSetRasterizerDiscardEnable_EXT] = vn_dispatch_vkCmdSetRasterizerDiscardEnable,
+    [VK_COMMAND_TYPE_vkCmdSetDepthBiasEnable_EXT] = vn_dispatch_vkCmdSetDepthBiasEnable,
+    [VK_COMMAND_TYPE_vkCmdSetLogicOpEXT_EXT] = vn_dispatch_vkCmdSetLogicOpEXT,
+    [VK_COMMAND_TYPE_vkCmdSetPrimitiveRestartEnable_EXT] = vn_dispatch_vkCmdSetPrimitiveRestartEnable,
+    [VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT] = vn_dispatch_vkCreatePrivateDataSlot,
+    [VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT] = vn_dispatch_vkDestroyPrivateDataSlot,
+    [VK_COMMAND_TYPE_vkSetPrivateData_EXT] = vn_dispatch_vkSetPrivateData,
+    [VK_COMMAND_TYPE_vkGetPrivateData_EXT] = vn_dispatch_vkGetPrivateData,
+    [VK_COMMAND_TYPE_vkCmdCopyBuffer2_EXT] = vn_dispatch_vkCmdCopyBuffer2,
+    [VK_COMMAND_TYPE_vkCmdCopyImage2_EXT] = vn_dispatch_vkCmdCopyImage2,
+    [VK_COMMAND_TYPE_vkCmdBlitImage2_EXT] = vn_dispatch_vkCmdBlitImage2,
+    [VK_COMMAND_TYPE_vkCmdCopyBufferToImage2_EXT] = vn_dispatch_vkCmdCopyBufferToImage2,
+    [VK_COMMAND_TYPE_vkCmdCopyImageToBuffer2_EXT] = vn_dispatch_vkCmdCopyImageToBuffer2,
+    [VK_COMMAND_TYPE_vkCmdResolveImage2_EXT] = vn_dispatch_vkCmdResolveImage2,
+    [VK_COMMAND_TYPE_vkCmdSetEvent2_EXT] = vn_dispatch_vkCmdSetEvent2,
+    [VK_COMMAND_TYPE_vkCmdResetEvent2_EXT] = vn_dispatch_vkCmdResetEvent2,
+    [VK_COMMAND_TYPE_vkCmdWaitEvents2_EXT] = vn_dispatch_vkCmdWaitEvents2,
+    [VK_COMMAND_TYPE_vkCmdPipelineBarrier2_EXT] = vn_dispatch_vkCmdPipelineBarrier2,
+    [VK_COMMAND_TYPE_vkQueueSubmit2_EXT] = vn_dispatch_vkQueueSubmit2,
+    [VK_COMMAND_TYPE_vkCmdWriteTimestamp2_EXT] = vn_dispatch_vkCmdWriteTimestamp2,
+    [VK_COMMAND_TYPE_vkCmdBeginRendering_EXT] = vn_dispatch_vkCmdBeginRendering,
+    [VK_COMMAND_TYPE_vkCmdEndRendering_EXT] = vn_dispatch_vkCmdEndRendering,
     [VK_COMMAND_TYPE_vkSetReplyCommandStreamMESA_EXT] = vn_dispatch_vkSetReplyCommandStreamMESA,
     [VK_COMMAND_TYPE_vkSeekReplyCommandStreamMESA_EXT] = vn_dispatch_vkSeekReplyCommandStreamMESA,
     [VK_COMMAND_TYPE_vkExecuteCommandStreamsMESA_EXT] = vn_dispatch_vkExecuteCommandStreamsMESA,
@@ -447,7 +526,7 @@ static inline void vn_dispatch_command(struct vn_dispatch_context *ctx)
 #ifdef DEBUG
         TRACE_SCOPE_SLOW(vn_dispatch_command_name(cmd_type));
 #endif
-        if (cmd_type < 196 && vn_dispatch_table[cmd_type])
+        if (cmd_type < 235 && vn_dispatch_table[cmd_type])
             vn_dispatch_table[cmd_type](ctx, cmd_flags);
         else
             vn_cs_decoder_set_fatal(ctx->decoder);

src/venus/venus-protocol/vn_protocol_renderer_handles.h

@@ -872,4 +872,35 @@ vn_replace_VkSamplerYcbcrConversion_handle(VkSamplerYcbcrConversion *val)
     *val = (VkSamplerYcbcrConversion)vn_cs_get_object_handle((const void **)val, VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION);
 }
 
+/* VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot) */
+
+static inline void
+vn_encode_VkPrivateDataSlot(struct vn_cs_encoder *enc, const VkPrivateDataSlot *val)
+{
+    const uint64_t id = vn_cs_handle_load_id((const void **)val, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT);
+    vn_encode_uint64_t(enc, &id);
+}
+
+static inline void
+vn_decode_VkPrivateDataSlot(struct vn_cs_decoder *dec, VkPrivateDataSlot *val)
+{
+    uint64_t id;
+    vn_decode_uint64_t(dec, &id);
+    vn_cs_handle_store_id((void **)val, id, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT);
+}
+
+static inline void
+vn_decode_VkPrivateDataSlot_lookup(struct vn_cs_decoder *dec, VkPrivateDataSlot *val)
+{
+    uint64_t id;
+    vn_decode_uint64_t(dec, &id);
+    *val = (VkPrivateDataSlot)(uintptr_t)vn_cs_decoder_lookup_object(dec, id, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT);
+}
+
+static inline void
+vn_replace_VkPrivateDataSlot_handle(VkPrivateDataSlot *val)
+{
+    *val = (VkPrivateDataSlot)vn_cs_get_object_handle((const void **)val, VK_OBJECT_TYPE_PRIVATE_DATA_SLOT);
+}
+
 #endif /* VN_PROTOCOL_RENDERER_HANDLES_H */

src/venus/venus-protocol/vn_protocol_renderer_image.h

@@ -38,6 +38,29 @@ vn_decode_VkSparseImageMemoryRequirements_partial_temp(struct vn_cs_decoder *dec
 
 /* struct VkExternalMemoryImageCreateInfo chain */
 
+static inline void
+vn_encode_VkExternalMemoryImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkExternalMemoryImageCreateInfo_self(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->handleTypes);
+}
+
+static inline void
+vn_encode_VkExternalMemoryImageCreateInfo(struct vn_cs_encoder *enc, const VkExternalMemoryImageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO });
+    vn_encode_VkExternalMemoryImageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkExternalMemoryImageCreateInfo_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkExternalMemoryImageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -95,6 +118,35 @@ vn_replace_VkExternalMemoryImageCreateInfo_handle(VkExternalMemoryImageCreateInf
 
 /* struct VkImageDrmFormatModifierListCreateInfoEXT chain */
 
+static inline void
+vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint32_t(enc, &val->drmFormatModifierCount);
+    if (val->pDrmFormatModifiers) {
+        vn_encode_array_size(enc, val->drmFormatModifierCount);
+        vn_encode_uint64_t_array(enc, val->pDrmFormatModifiers, val->drmFormatModifierCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierListCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierListCreateInfoEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT });
+    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_pnext(enc, val->pNext);
+    vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkImageDrmFormatModifierListCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -204,6 +256,37 @@ vn_replace_VkSubresourceLayout_handle(VkSubresourceLayout *val)
 
 /* struct VkImageDrmFormatModifierExplicitCreateInfoEXT chain */
 
+static inline void
+vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_uint64_t(enc, &val->drmFormatModifier);
+    vn_encode_uint32_t(enc, &val->drmFormatModifierPlaneCount);
+    if (val->pPlaneLayouts) {
+        vn_encode_array_size(enc, val->drmFormatModifierPlaneCount);
+        for (uint32_t i = 0; i < val->drmFormatModifierPlaneCount; i++)
+            vn_encode_VkSubresourceLayout(enc, &val->pPlaneLayouts[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
+static inline void
+vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT(struct vn_cs_encoder *enc, const VkImageDrmFormatModifierExplicitCreateInfoEXT *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT });
+    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext(enc, val->pNext);
+    vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkImageDrmFormatModifierExplicitCreateInfoEXT_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -277,6 +360,86 @@ vn_replace_VkImageDrmFormatModifierExplicitCreateInfoEXT_handle(VkImageDrmFormat
 
 /* struct VkImageCreateInfo chain */
 
+static inline void
+vn_encode_VkImageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    const VkBaseInStructure *pnext = val;
+
+    while (pnext) {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkExternalMemoryImageCreateInfo_self(enc, (const VkExternalMemoryImageCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageFormatListCreateInfo_self(enc, (const VkImageFormatListCreateInfo *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageDrmFormatModifierListCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierListCreateInfoEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageDrmFormatModifierExplicitCreateInfoEXT_self(enc, (const VkImageDrmFormatModifierExplicitCreateInfoEXT *)pnext);
+            return;
+        case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO:
+            vn_encode_simple_pointer(enc, pnext);
+            vn_encode_VkStructureType(enc, &pnext->sType);
+            vn_encode_VkImageCreateInfo_pnext(enc, pnext->pNext);
+            vn_encode_VkImageStencilUsageCreateInfo_self(enc, (const VkImageStencilUsageCreateInfo *)pnext);
+            return;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    }
+
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->flags);
+    vn_encode_VkImageType(enc, &val->imageType);
+    vn_encode_VkFormat(enc, &val->format);
+    vn_encode_VkExtent3D(enc, &val->extent);
+    vn_encode_uint32_t(enc, &val->mipLevels);
+    vn_encode_uint32_t(enc, &val->arrayLayers);
+    vn_encode_VkSampleCountFlagBits(enc, &val->samples);
+    vn_encode_VkImageTiling(enc, &val->tiling);
+    vn_encode_VkFlags(enc, &val->usage);
+    vn_encode_VkSharingMode(enc, &val->sharingMode);
+    vn_encode_uint32_t(enc, &val->queueFamilyIndexCount);
+    if (val->pQueueFamilyIndices) {
+        vn_encode_array_size(enc, val->queueFamilyIndexCount);
+        vn_encode_uint32_t_array(enc, val->pQueueFamilyIndices, val->queueFamilyIndexCount);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+    vn_encode_VkImageLayout(enc, &val->initialLayout);
+}
+
+static inline void
+vn_encode_VkImageCreateInfo(struct vn_cs_encoder *enc, const VkImageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO });
+    vn_encode_VkImageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageCreateInfo_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkImageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -1021,6 +1184,73 @@ vn_decode_VkSparseImageMemoryRequirements2_partial_temp(struct vn_cs_decoder *de
     vn_decode_VkSparseImageMemoryRequirements2_self_partial_temp(dec, val);
 }
 
+/* struct VkDeviceImageMemoryRequirements chain */
+
+static inline void *
+vn_decode_VkDeviceImageMemoryRequirements_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkDeviceImageMemoryRequirements_self_temp(struct vn_cs_decoder *dec, VkDeviceImageMemoryRequirements *val)
+{
+    /* skip val->{sType,pNext} */
+    if (vn_decode_simple_pointer(dec)) {
+        val->pCreateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pCreateInfo));
+        if (!val->pCreateInfo) return;
+        vn_decode_VkImageCreateInfo_temp(dec, (VkImageCreateInfo *)val->pCreateInfo);
+    } else {
+        val->pCreateInfo = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+    vn_decode_VkImageAspectFlagBits(dec, &val->planeAspect);
+}
+
+static inline void
+vn_decode_VkDeviceImageMemoryRequirements_temp(struct vn_cs_decoder *dec, VkDeviceImageMemoryRequirements *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkDeviceImageMemoryRequirements_pnext_temp(dec);
+    vn_decode_VkDeviceImageMemoryRequirements_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkDeviceImageMemoryRequirements_handle_self(VkDeviceImageMemoryRequirements *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    if (val->pCreateInfo)
+        vn_replace_VkImageCreateInfo_handle((VkImageCreateInfo *)val->pCreateInfo);
+    /* skip val->planeAspect */
+}
+
+static inline void
+vn_replace_VkDeviceImageMemoryRequirements_handle(VkDeviceImageMemoryRequirements *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS:
+            vn_replace_VkDeviceImageMemoryRequirements_handle_self((VkDeviceImageMemoryRequirements *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
 /* struct VkImageDrmFormatModifierPropertiesEXT chain */
 
 static inline void
@@ -1430,6 +1660,102 @@ static inline void vn_encode_vkGetImageSparseMemoryRequirements2_reply(struct vn
     }
 }
 
+static inline void vn_decode_vkGetDeviceImageMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceImageMemoryRequirements *args)
+{
+    vn_decode_VkDevice_lookup(dec, &args->device);
+    if (vn_decode_simple_pointer(dec)) {
+        args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
+        if (!args->pInfo) return;
+        vn_decode_VkDeviceImageMemoryRequirements_temp(dec, (VkDeviceImageMemoryRequirements *)args->pInfo);
+    } else {
+        args->pInfo = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+    if (vn_decode_simple_pointer(dec)) {
+        args->pMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pMemoryRequirements));
+        if (!args->pMemoryRequirements) return;
+        vn_decode_VkMemoryRequirements2_partial_temp(dec, args->pMemoryRequirements);
+    } else {
+        args->pMemoryRequirements = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+}
+
+static inline void vn_replace_vkGetDeviceImageMemoryRequirements_args_handle(struct vn_command_vkGetDeviceImageMemoryRequirements *args)
+{
+    vn_replace_VkDevice_handle(&args->device);
+    if (args->pInfo)
+        vn_replace_VkDeviceImageMemoryRequirements_handle((VkDeviceImageMemoryRequirements *)args->pInfo);
+    /* skip args->pMemoryRequirements */
+}
+
+static inline void vn_encode_vkGetDeviceImageMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceImageMemoryRequirements *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceImageMemoryRequirements_EXT});
+
+    /* skip args->device */
+    /* skip args->pInfo */
+    if (vn_encode_simple_pointer(enc, args->pMemoryRequirements))
+        vn_encode_VkMemoryRequirements2(enc, args->pMemoryRequirements);
+}
+
+static inline void vn_decode_vkGetDeviceImageSparseMemoryRequirements_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetDeviceImageSparseMemoryRequirements *args)
+{
+    vn_decode_VkDevice_lookup(dec, &args->device);
+    if (vn_decode_simple_pointer(dec)) {
+        args->pInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pInfo));
+        if (!args->pInfo) return;
+        vn_decode_VkDeviceImageMemoryRequirements_temp(dec, (VkDeviceImageMemoryRequirements *)args->pInfo);
+    } else {
+        args->pInfo = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+    if (vn_decode_simple_pointer(dec)) {
+        args->pSparseMemoryRequirementCount = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirementCount));
+        if (!args->pSparseMemoryRequirementCount) return;
+        vn_decode_uint32_t(dec, args->pSparseMemoryRequirementCount);
+    } else {
+        args->pSparseMemoryRequirementCount = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+    if (vn_peek_array_size(dec)) {
+        const uint32_t iter_count = vn_decode_array_size(dec, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
+        args->pSparseMemoryRequirements = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSparseMemoryRequirements) * iter_count);
+        if (!args->pSparseMemoryRequirements) return;
+        for (uint32_t i = 0; i < iter_count; i++)
+            vn_decode_VkSparseImageMemoryRequirements2_partial_temp(dec, &args->pSparseMemoryRequirements[i]);
+    } else {
+        vn_decode_array_size_unchecked(dec);
+        args->pSparseMemoryRequirements = NULL;
+    }
+}
+
+static inline void vn_replace_vkGetDeviceImageSparseMemoryRequirements_args_handle(struct vn_command_vkGetDeviceImageSparseMemoryRequirements *args)
+{
+    vn_replace_VkDevice_handle(&args->device);
+    if (args->pInfo)
+        vn_replace_VkDeviceImageMemoryRequirements_handle((VkDeviceImageMemoryRequirements *)args->pInfo);
+    /* skip args->pSparseMemoryRequirementCount */
+    /* skip args->pSparseMemoryRequirements */
+}
+
+static inline void vn_encode_vkGetDeviceImageSparseMemoryRequirements_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetDeviceImageSparseMemoryRequirements *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetDeviceImageSparseMemoryRequirements_EXT});
+
+    /* skip args->device */
+    /* skip args->pInfo */
+    if (vn_encode_simple_pointer(enc, args->pSparseMemoryRequirementCount))
+        vn_encode_uint32_t(enc, args->pSparseMemoryRequirementCount);
+    if (args->pSparseMemoryRequirements) {
+        vn_encode_array_size(enc, (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0));
+        for (uint32_t i = 0; i < (args->pSparseMemoryRequirementCount ? *args->pSparseMemoryRequirementCount : 0); i++)
+            vn_encode_VkSparseImageMemoryRequirements2(enc, &args->pSparseMemoryRequirements[i]);
+    } else {
+        vn_encode_array_size(enc, 0);
+    }
+}
+
 static inline void vn_decode_vkGetImageDrmFormatModifierPropertiesEXT_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT *args)
 {
     vn_decode_VkDevice_lookup(dec, &args->device);
@@ -1699,6 +2025,56 @@ static inline void vn_dispatch_vkGetImageSparseMemoryRequirements2(struct vn_dis
     vn_cs_decoder_reset_temp_pool(ctx->decoder);
 }
 
+static inline void vn_dispatch_vkGetDeviceImageMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkGetDeviceImageMemoryRequirements args;
+
+    if (!ctx->dispatch_vkGetDeviceImageMemoryRequirements) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkGetDeviceImageMemoryRequirements_args_temp(ctx->decoder, &args);
+    if (!args.device) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkGetDeviceImageMemoryRequirements(ctx, &args);
+
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkGetDeviceImageMemoryRequirements_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
+static inline void vn_dispatch_vkGetDeviceImageSparseMemoryRequirements(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkGetDeviceImageSparseMemoryRequirements args;
+
+    if (!ctx->dispatch_vkGetDeviceImageSparseMemoryRequirements) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkGetDeviceImageSparseMemoryRequirements_args_temp(ctx->decoder, &args);
+    if (!args.device) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkGetDeviceImageSparseMemoryRequirements(ctx, &args);
+
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkGetDeviceImageSparseMemoryRequirements_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
 static inline void vn_dispatch_vkGetImageDrmFormatModifierPropertiesEXT(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
 {
     struct vn_command_vkGetImageDrmFormatModifierPropertiesEXT args;

src/venus/venus-protocol/vn_protocol_renderer_info.h

@@ -12,23 +12,38 @@
 
 struct vn_info_extension_table {
    union {
-      bool enabled[54];
+      bool enabled[77];
       struct {
+         bool EXT_4444_formats;
          bool EXT_command_serialization;
          bool EXT_descriptor_indexing;
+         bool EXT_extended_dynamic_state;
+         bool EXT_extended_dynamic_state2;
          bool EXT_external_memory_dma_buf;
          bool EXT_host_query_reset;
          bool EXT_image_drm_format_modifier;
+         bool EXT_image_robustness;
+         bool EXT_inline_uniform_block;
+         bool EXT_pipeline_creation_cache_control;
+         bool EXT_pipeline_creation_feedback;
+         bool EXT_private_data;
          bool EXT_queue_family_foreign;
          bool EXT_sampler_filter_minmax;
          bool EXT_scalar_block_layout;
          bool EXT_separate_stencil_usage;
+         bool EXT_shader_demote_to_helper_invocation;
          bool EXT_shader_viewport_index_layer;
+         bool EXT_subgroup_size_control;
+         bool EXT_texel_buffer_alignment;
+         bool EXT_texture_compression_astc_hdr;
+         bool EXT_tooling_info;
          bool EXT_transform_feedback;
+         bool EXT_ycbcr_2plane_444_formats;
          bool KHR_16bit_storage;
          bool KHR_8bit_storage;
          bool KHR_bind_memory2;
          bool KHR_buffer_device_address;
+         bool KHR_copy_commands2;
          bool KHR_create_renderpass2;
          bool KHR_dedicated_allocation;
          bool KHR_depth_stencil_resolve;
@@ -37,6 +52,7 @@ struct vn_info_extension_table {
          bool KHR_device_group_creation;
          bool KHR_draw_indirect_count;
          bool KHR_driver_properties;
+         bool KHR_dynamic_rendering;
          bool KHR_external_fence;
          bool KHR_external_fence_capabilities;
          bool KHR_external_memory;
@@ -44,6 +60,7 @@ struct vn_info_extension_table {
          bool KHR_external_memory_fd;
          bool KHR_external_semaphore;
          bool KHR_external_semaphore_capabilities;
+         bool KHR_format_feature_flags2;
          bool KHR_get_memory_requirements2;
          bool KHR_get_physical_device_properties2;
          bool KHR_image_format_list;
@@ -51,6 +68,7 @@ struct vn_info_extension_table {
          bool KHR_maintenance1;
          bool KHR_maintenance2;
          bool KHR_maintenance3;
+         bool KHR_maintenance4;
          bool KHR_multiview;
          bool KHR_relaxed_block_layout;
          bool KHR_sampler_mirror_clamp_to_edge;
@@ -60,13 +78,18 @@ struct vn_info_extension_table {
          bool KHR_shader_draw_parameters;
          bool KHR_shader_float16_int8;
          bool KHR_shader_float_controls;
+         bool KHR_shader_integer_dot_product;
+         bool KHR_shader_non_semantic_info;
          bool KHR_shader_subgroup_extended_types;
+         bool KHR_shader_terminate_invocation;
          bool KHR_spirv_1_4;
          bool KHR_storage_buffer_storage_class;
+         bool KHR_synchronization2;
          bool KHR_timeline_semaphore;
          bool KHR_uniform_buffer_standard_layout;
          bool KHR_variable_pointers;
          bool KHR_vulkan_memory_model;
+         bool KHR_zero_initialize_workgroup_memory;
          bool MESA_venus_protocol;
       };
    };
@@ -88,7 +111,7 @@ vn_info_wire_format_version(void)
 static inline uint32_t
 vn_info_vk_xml_version(void)
 {
-    return VK_MAKE_API_VERSION(0, 1, 2, 182);
+    return VK_MAKE_API_VERSION(0, 1, 3, 204);
 }
 
 static inline int
@@ -100,64 +123,87 @@ vn_info_extension_compare(const void *name, const void *ext)
 static inline const struct vn_info_extension *
 vn_info_extension_get(const char *name)
 {
-   static const struct vn_info_extension vn_info_extensions[54] = {
+   static const struct vn_info_extension vn_info_extensions[77] = {
-      { 0, "VK_EXT_command_serialization", 0 },
+      { 0, "VK_EXT_4444_formats", 1 },
-      { 1, "VK_EXT_descriptor_indexing", 2 },
+      { 1, "VK_EXT_command_serialization", 0 },
-      { 2, "VK_EXT_external_memory_dma_buf", 1 },
+      { 2, "VK_EXT_descriptor_indexing", 2 },
-      { 3, "VK_EXT_host_query_reset", 1 },
+      { 3, "VK_EXT_extended_dynamic_state", 1 },
-      { 4, "VK_EXT_image_drm_format_modifier", 1 },
+      { 4, "VK_EXT_extended_dynamic_state2", 1 },
-      { 5, "VK_EXT_queue_family_foreign", 1 },
+      { 5, "VK_EXT_external_memory_dma_buf", 1 },
-      { 6, "VK_EXT_sampler_filter_minmax", 2 },
+      { 6, "VK_EXT_host_query_reset", 1 },
-      { 7, "VK_EXT_scalar_block_layout", 1 },
+      { 7, "VK_EXT_image_drm_format_modifier", 2 },
-      { 8, "VK_EXT_separate_stencil_usage", 1 },
+      { 8, "VK_EXT_image_robustness", 1 },
-      { 9, "VK_EXT_shader_viewport_index_layer", 1 },
+      { 9, "VK_EXT_inline_uniform_block", 1 },
-      { 10, "VK_EXT_transform_feedback", 1 },
+      { 10, "VK_EXT_pipeline_creation_cache_control", 3 },
-      { 11, "VK_KHR_16bit_storage", 1 },
+      { 11, "VK_EXT_pipeline_creation_feedback", 1 },
-      { 12, "VK_KHR_8bit_storage", 1 },
+      { 12, "VK_EXT_private_data", 1 },
-      { 13, "VK_KHR_bind_memory2", 1 },
+      { 13, "VK_EXT_queue_family_foreign", 1 },
-      { 14, "VK_KHR_buffer_device_address", 1 },
+      { 14, "VK_EXT_sampler_filter_minmax", 2 },
-      { 15, "VK_KHR_create_renderpass2", 1 },
+      { 15, "VK_EXT_scalar_block_layout", 1 },
-      { 16, "VK_KHR_dedicated_allocation", 3 },
+      { 16, "VK_EXT_separate_stencil_usage", 1 },
-      { 17, "VK_KHR_depth_stencil_resolve", 1 },
+      { 17, "VK_EXT_shader_demote_to_helper_invocation", 1 },
-      { 18, "VK_KHR_descriptor_update_template", 1 },
+      { 18, "VK_EXT_shader_viewport_index_layer", 1 },
-      { 19, "VK_KHR_device_group", 4 },
+      { 19, "VK_EXT_subgroup_size_control", 2 },
-      { 20, "VK_KHR_device_group_creation", 1 },
+      { 20, "VK_EXT_texel_buffer_alignment", 1 },
-      { 21, "VK_KHR_draw_indirect_count", 1 },
+      { 21, "VK_EXT_texture_compression_astc_hdr", 1 },
-      { 22, "VK_KHR_driver_properties", 1 },
+      { 22, "VK_EXT_tooling_info", 1 },
-      { 23, "VK_KHR_external_fence", 1 },
+      { 23, "VK_EXT_transform_feedback", 1 },
-      { 24, "VK_KHR_external_fence_capabilities", 1 },
+      { 24, "VK_EXT_ycbcr_2plane_444_formats", 1 },
-      { 25, "VK_KHR_external_memory", 1 },
+      { 25, "VK_KHR_16bit_storage", 1 },
-      { 26, "VK_KHR_external_memory_capabilities", 1 },
+      { 26, "VK_KHR_8bit_storage", 1 },
-      { 27, "VK_KHR_external_memory_fd", 1 },
+      { 27, "VK_KHR_bind_memory2", 1 },
-      { 28, "VK_KHR_external_semaphore", 1 },
+      { 28, "VK_KHR_buffer_device_address", 1 },
-      { 29, "VK_KHR_external_semaphore_capabilities", 1 },
+      { 29, "VK_KHR_copy_commands2", 1 },
-      { 30, "VK_KHR_get_memory_requirements2", 1 },
+      { 30, "VK_KHR_create_renderpass2", 1 },
-      { 31, "VK_KHR_get_physical_device_properties2", 2 },
+      { 31, "VK_KHR_dedicated_allocation", 3 },
-      { 32, "VK_KHR_image_format_list", 1 },
+      { 32, "VK_KHR_depth_stencil_resolve", 1 },
-      { 33, "VK_KHR_imageless_framebuffer", 1 },
+      { 33, "VK_KHR_descriptor_update_template", 1 },
-      { 34, "VK_KHR_maintenance1", 2 },
+      { 34, "VK_KHR_device_group", 4 },
-      { 35, "VK_KHR_maintenance2", 1 },
+      { 35, "VK_KHR_device_group_creation", 1 },
-      { 36, "VK_KHR_maintenance3", 1 },
+      { 36, "VK_KHR_draw_indirect_count", 1 },
-      { 37, "VK_KHR_multiview", 1 },
+      { 37, "VK_KHR_driver_properties", 1 },
-      { 38, "VK_KHR_relaxed_block_layout", 1 },
+      { 38, "VK_KHR_dynamic_rendering", 1 },
-      { 39, "VK_KHR_sampler_mirror_clamp_to_edge", 3 },
+      { 39, "VK_KHR_external_fence", 1 },
-      { 40, "VK_KHR_sampler_ycbcr_conversion", 14 },
+      { 40, "VK_KHR_external_fence_capabilities", 1 },
-      { 41, "VK_KHR_separate_depth_stencil_layouts", 1 },
+      { 41, "VK_KHR_external_memory", 1 },
-      { 42, "VK_KHR_shader_atomic_int64", 1 },
+      { 42, "VK_KHR_external_memory_capabilities", 1 },
-      { 43, "VK_KHR_shader_draw_parameters", 1 },
+      { 43, "VK_KHR_external_memory_fd", 1 },
-      { 44, "VK_KHR_shader_float16_int8", 1 },
+      { 44, "VK_KHR_external_semaphore", 1 },
-      { 45, "VK_KHR_shader_float_controls", 4 },
+      { 45, "VK_KHR_external_semaphore_capabilities", 1 },
-      { 46, "VK_KHR_shader_subgroup_extended_types", 1 },
+      { 46, "VK_KHR_format_feature_flags2", 1 },
-      { 47, "VK_KHR_spirv_1_4", 1 },
+      { 47, "VK_KHR_get_memory_requirements2", 1 },
-      { 48, "VK_KHR_storage_buffer_storage_class", 1 },
+      { 48, "VK_KHR_get_physical_device_properties2", 2 },
-      { 49, "VK_KHR_timeline_semaphore", 2 },
+      { 49, "VK_KHR_image_format_list", 1 },
-      { 50, "VK_KHR_uniform_buffer_standard_layout", 1 },
+      { 50, "VK_KHR_imageless_framebuffer", 1 },
-      { 51, "VK_KHR_variable_pointers", 1 },
+      { 51, "VK_KHR_maintenance1", 2 },
-      { 52, "VK_KHR_vulkan_memory_model", 3 },
+      { 52, "VK_KHR_maintenance2", 1 },
-      { 53, "VK_MESA_venus_protocol", 100000 },
+      { 53, "VK_KHR_maintenance3", 1 },
+      { 54, "VK_KHR_maintenance4", 2 },
+      { 55, "VK_KHR_multiview", 1 },
+      { 56, "VK_KHR_relaxed_block_layout", 1 },
+      { 57, "VK_KHR_sampler_mirror_clamp_to_edge", 3 },
+      { 58, "VK_KHR_sampler_ycbcr_conversion", 14 },
+      { 59, "VK_KHR_separate_depth_stencil_layouts", 1 },
+      { 60, "VK_KHR_shader_atomic_int64", 1 },
+      { 61, "VK_KHR_shader_draw_parameters", 1 },
+      { 62, "VK_KHR_shader_float16_int8", 1 },
+      { 63, "VK_KHR_shader_float_controls", 4 },
+      { 64, "VK_KHR_shader_integer_dot_product", 1 },
+      { 65, "VK_KHR_shader_non_semantic_info", 1 },
+      { 66, "VK_KHR_shader_subgroup_extended_types", 1 },
+      { 67, "VK_KHR_shader_terminate_invocation", 1 },
+      { 68, "VK_KHR_spirv_1_4", 1 },
+      { 69, "VK_KHR_storage_buffer_storage_class", 1 },
+      { 70, "VK_KHR_synchronization2", 1 },
+      { 71, "VK_KHR_timeline_semaphore", 2 },
+      { 72, "VK_KHR_uniform_buffer_standard_layout", 1 },
+      { 73, "VK_KHR_variable_pointers", 1 },
+      { 74, "VK_KHR_vulkan_memory_model", 3 },
+      { 75, "VK_KHR_zero_initialize_workgroup_memory", 1 },
+      { 76, "VK_MESA_venus_protocol", 100000 },
    };
 
-   return bsearch(name, vn_info_extensions, 54,
+   return bsearch(name, vn_info_extensions, 77,
          sizeof(*vn_info_extensions), vn_info_extension_compare);
 }
 

src/venus/venus-protocol/vn_protocol_renderer_pipeline.h

@@ -72,10 +72,10 @@ vn_replace_VkSpecializationInfo_handle(VkSpecializationInfo *val)
     /* skip val->pData */
 }
 
-/* struct VkPipelineShaderStageCreateInfo chain */
+/* struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo chain */
 
 static inline void *
-vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
     /* no known/supported struct */
     if (vn_decode_simple_pointer(dec))
@@ -83,6 +83,83 @@ vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
     return NULL;
 }
 
+static inline void
+vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->requiredSubgroupSize);
+}
+
+static inline void
+vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_pnext_temp(dec);
+    vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle_self(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    /* skip val->requiredSubgroupSize */
+}
+
+static inline void
+vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+            vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle_self((VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+/* struct VkPipelineShaderStageCreateInfo chain */
+
+static inline void *
+vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+{
+    VkBaseOutStructure *pnext;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return NULL;
+
+    vn_decode_VkStructureType(dec, &stype);
+    switch ((int32_t)stype) {
+    case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+        pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo));
+        if (pnext) {
+            pnext->sType = stype;
+            pnext->pNext = vn_decode_VkPipelineShaderStageCreateInfo_pnext_temp(dec);
+            vn_decode_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_self_temp(dec, (VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
+        }
+        break;
+    default:
+        /* unexpected struct */
+        pnext = NULL;
+        vn_cs_decoder_set_fatal(dec);
+        break;
+    }
+
+    return pnext;
+}
+
 static inline void
 vn_decode_VkPipelineShaderStageCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineShaderStageCreateInfo *val)
 {
@@ -144,6 +221,9 @@ vn_replace_VkPipelineShaderStageCreateInfo_handle(VkPipelineShaderStageCreateInf
         case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO:
             vn_replace_VkPipelineShaderStageCreateInfo_handle_self((VkPipelineShaderStageCreateInfo *)pnext);
             break;
+        case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO:
+            vn_replace_VkPipelineShaderStageRequiredSubgroupSizeCreateInfo_handle_self((VkPipelineShaderStageRequiredSubgroupSizeCreateInfo *)pnext);
+            break;
         default:
             /* ignore unknown/unsupported struct */
             break;
@@ -1084,10 +1164,26 @@ vn_replace_VkPipelineDynamicStateCreateInfo_handle(VkPipelineDynamicStateCreateI
     } while (pnext);
 }
 
-/* struct VkGraphicsPipelineCreateInfo chain */
+/* struct VkPipelineCreationFeedback */
+
+static inline void
+vn_decode_VkPipelineCreationFeedback_temp(struct vn_cs_decoder *dec, VkPipelineCreationFeedback *val)
+{
+    vn_decode_VkFlags(dec, &val->flags);
+    vn_decode_uint64_t(dec, &val->duration);
+}
+
+static inline void
+vn_replace_VkPipelineCreationFeedback_handle(VkPipelineCreationFeedback *val)
+{
+    /* skip val->flags */
+    /* skip val->duration */
+}
+
+/* struct VkPipelineCreationFeedbackCreateInfo chain */
 
 static inline void *
-vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+vn_decode_VkPipelineCreationFeedbackCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
     /* no known/supported struct */
     if (vn_decode_simple_pointer(dec))
@@ -1095,6 +1191,188 @@ vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
     return NULL;
 }
 
+static inline void
+vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    if (vn_decode_simple_pointer(dec)) {
+        val->pPipelineCreationFeedback = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pPipelineCreationFeedback));
+        if (!val->pPipelineCreationFeedback) return;
+        vn_decode_VkPipelineCreationFeedback_temp(dec, val->pPipelineCreationFeedback);
+    } else {
+        val->pPipelineCreationFeedback = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+    vn_decode_uint32_t(dec, &val->pipelineStageCreationFeedbackCount);
+    if (vn_peek_array_size(dec)) {
+        const uint32_t iter_count = vn_decode_array_size(dec, val->pipelineStageCreationFeedbackCount);
+        val->pPipelineStageCreationFeedbacks = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pPipelineStageCreationFeedbacks) * iter_count);
+        if (!val->pPipelineStageCreationFeedbacks) return;
+        for (uint32_t i = 0; i < iter_count; i++)
+            vn_decode_VkPipelineCreationFeedback_temp(dec, &val->pPipelineStageCreationFeedbacks[i]);
+    } else {
+        vn_decode_array_size(dec, val->pipelineStageCreationFeedbackCount);
+        val->pPipelineStageCreationFeedbacks = NULL;
+    }
+}
+
+static inline void
+vn_decode_VkPipelineCreationFeedbackCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackCreateInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkPipelineCreationFeedbackCreateInfo_pnext_temp(dec);
+    vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self(VkPipelineCreationFeedbackCreateInfo *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    if (val->pPipelineCreationFeedback)
+        vn_replace_VkPipelineCreationFeedback_handle(val->pPipelineCreationFeedback);
+    /* skip val->pipelineStageCreationFeedbackCount */
+    if (val->pPipelineStageCreationFeedbacks) {
+       for (uint32_t i = 0; i < val->pipelineStageCreationFeedbackCount; i++)
+            vn_replace_VkPipelineCreationFeedback_handle(&val->pPipelineStageCreationFeedbacks[i]);
+    }
+}
+
+static inline void
+vn_replace_VkPipelineCreationFeedbackCreateInfo_handle(VkPipelineCreationFeedbackCreateInfo *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+            vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self((VkPipelineCreationFeedbackCreateInfo *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+/* struct VkPipelineRenderingCreateInfo chain */
+
+static inline void *
+vn_decode_VkPipelineRenderingCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkPipelineRenderingCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPipelineRenderingCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_uint32_t(dec, &val->viewMask);
+    vn_decode_uint32_t(dec, &val->colorAttachmentCount);
+    if (vn_peek_array_size(dec)) {
+        const size_t array_size = vn_decode_array_size(dec, val->colorAttachmentCount);
+        val->pColorAttachmentFormats = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pColorAttachmentFormats) * array_size);
+        if (!val->pColorAttachmentFormats) return;
+        vn_decode_VkFormat_array(dec, (VkFormat *)val->pColorAttachmentFormats, array_size);
+    } else {
+        vn_decode_array_size(dec, val->colorAttachmentCount);
+        val->pColorAttachmentFormats = NULL;
+    }
+    vn_decode_VkFormat(dec, &val->depthAttachmentFormat);
+    vn_decode_VkFormat(dec, &val->stencilAttachmentFormat);
+}
+
+static inline void
+vn_decode_VkPipelineRenderingCreateInfo_temp(struct vn_cs_decoder *dec, VkPipelineRenderingCreateInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkPipelineRenderingCreateInfo_pnext_temp(dec);
+    vn_decode_VkPipelineRenderingCreateInfo_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkPipelineRenderingCreateInfo_handle_self(VkPipelineRenderingCreateInfo *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    /* skip val->viewMask */
+    /* skip val->colorAttachmentCount */
+    /* skip val->pColorAttachmentFormats */
+    /* skip val->depthAttachmentFormat */
+    /* skip val->stencilAttachmentFormat */
+}
+
+static inline void
+vn_replace_VkPipelineRenderingCreateInfo_handle(VkPipelineRenderingCreateInfo *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+            vn_replace_VkPipelineRenderingCreateInfo_handle_self((VkPipelineRenderingCreateInfo *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+/* struct VkGraphicsPipelineCreateInfo chain */
+
+static inline void *
+vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+{
+    VkBaseOutStructure *pnext;
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return NULL;
+
+    vn_decode_VkStructureType(dec, &stype);
+    switch ((int32_t)stype) {
+    case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+        pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineCreationFeedbackCreateInfo));
+        if (pnext) {
+            pnext->sType = stype;
+            pnext->pNext = vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(dec);
+            vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(dec, (VkPipelineCreationFeedbackCreateInfo *)pnext);
+        }
+        break;
+    case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+        pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineRenderingCreateInfo));
+        if (pnext) {
+            pnext->sType = stype;
+            pnext->pNext = vn_decode_VkGraphicsPipelineCreateInfo_pnext_temp(dec);
+            vn_decode_VkPipelineRenderingCreateInfo_self_temp(dec, (VkPipelineRenderingCreateInfo *)pnext);
+        }
+        break;
+    default:
+        /* unexpected struct */
+        pnext = NULL;
+        vn_cs_decoder_set_fatal(dec);
+        break;
+    }
+
+    return pnext;
+}
+
 static inline void
 vn_decode_VkGraphicsPipelineCreateInfo_self_temp(struct vn_cs_decoder *dec, VkGraphicsPipelineCreateInfo *val)
 {
@@ -1241,6 +1519,12 @@ vn_replace_VkGraphicsPipelineCreateInfo_handle(VkGraphicsPipelineCreateInfo *val
         case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO:
             vn_replace_VkGraphicsPipelineCreateInfo_handle_self((VkGraphicsPipelineCreateInfo *)pnext);
             break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+            vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self((VkPipelineCreationFeedbackCreateInfo *)pnext);
+            break;
+        case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO:
+            vn_replace_VkPipelineRenderingCreateInfo_handle_self((VkPipelineRenderingCreateInfo *)pnext);
+            break;
         default:
             /* ignore unknown/unsupported struct */
             break;
@@ -1254,10 +1538,30 @@ vn_replace_VkGraphicsPipelineCreateInfo_handle(VkGraphicsPipelineCreateInfo *val
 static inline void *
 vn_decode_VkComputePipelineCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
-    /* no known/supported struct */
+    VkBaseOutStructure *pnext;
-    if (vn_decode_simple_pointer(dec))
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return NULL;
+
+    vn_decode_VkStructureType(dec, &stype);
+    switch ((int32_t)stype) {
+    case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+        pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkPipelineCreationFeedbackCreateInfo));
+        if (pnext) {
+            pnext->sType = stype;
+            pnext->pNext = vn_decode_VkComputePipelineCreateInfo_pnext_temp(dec);
+            vn_decode_VkPipelineCreationFeedbackCreateInfo_self_temp(dec, (VkPipelineCreationFeedbackCreateInfo *)pnext);
+        }
+        break;
+    default:
+        /* unexpected struct */
+        pnext = NULL;
         vn_cs_decoder_set_fatal(dec);
-    return NULL;
+        break;
+    }
+
+    return pnext;
 }
 
 static inline void
@@ -1306,6 +1610,9 @@ vn_replace_VkComputePipelineCreateInfo_handle(VkComputePipelineCreateInfo *val)
         case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO:
             vn_replace_VkComputePipelineCreateInfo_handle_self((VkComputePipelineCreateInfo *)pnext);
             break;
+        case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO:
+            vn_replace_VkPipelineCreationFeedbackCreateInfo_handle_self((VkPipelineCreationFeedbackCreateInfo *)pnext);
+            break;
         default:
             /* ignore unknown/unsupported struct */
             break;

src/venus/venus-protocol/vn_protocol_renderer_private_data_slot.h

@@ -0,0 +1,324 @@
+/* This file is generated by venus-protocol.  See vn_protocol_renderer.h. */
+
+/*
+ * Copyright 2020 Google LLC
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef VN_PROTOCOL_RENDERER_PRIVATE_DATA_SLOT_H
+#define VN_PROTOCOL_RENDERER_PRIVATE_DATA_SLOT_H
+
+#include "vn_protocol_renderer_structs.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpointer-arith"
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+
+/* struct VkPrivateDataSlotCreateInfo chain */
+
+static inline void *
+vn_decode_VkPrivateDataSlotCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkPrivateDataSlotCreateInfo_self_temp(struct vn_cs_decoder *dec, VkPrivateDataSlotCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFlags(dec, &val->flags);
+}
+
+static inline void
+vn_decode_VkPrivateDataSlotCreateInfo_temp(struct vn_cs_decoder *dec, VkPrivateDataSlotCreateInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkPrivateDataSlotCreateInfo_pnext_temp(dec);
+    vn_decode_VkPrivateDataSlotCreateInfo_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkPrivateDataSlotCreateInfo_handle_self(VkPrivateDataSlotCreateInfo *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    /* skip val->flags */
+}
+
+static inline void
+vn_replace_VkPrivateDataSlotCreateInfo_handle(VkPrivateDataSlotCreateInfo *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO:
+            vn_replace_VkPrivateDataSlotCreateInfo_handle_self((VkPrivateDataSlotCreateInfo *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+static inline void vn_decode_vkCreatePrivateDataSlot_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkCreatePrivateDataSlot *args)
+{
+    vn_decode_VkDevice_lookup(dec, &args->device);
+    if (vn_decode_simple_pointer(dec)) {
+        args->pCreateInfo = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pCreateInfo));
+        if (!args->pCreateInfo) return;
+        vn_decode_VkPrivateDataSlotCreateInfo_temp(dec, (VkPrivateDataSlotCreateInfo *)args->pCreateInfo);
+    } else {
+        args->pCreateInfo = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+    if (vn_decode_simple_pointer(dec)) {
+        vn_cs_decoder_set_fatal(dec);
+    } else {
+        args->pAllocator = NULL;
+    }
+    if (vn_decode_simple_pointer(dec)) {
+        args->pPrivateDataSlot = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pPrivateDataSlot));
+        if (!args->pPrivateDataSlot) return;
+        vn_decode_VkPrivateDataSlot(dec, args->pPrivateDataSlot);
+    } else {
+        args->pPrivateDataSlot = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+}
+
+static inline void vn_replace_vkCreatePrivateDataSlot_args_handle(struct vn_command_vkCreatePrivateDataSlot *args)
+{
+    vn_replace_VkDevice_handle(&args->device);
+    if (args->pCreateInfo)
+        vn_replace_VkPrivateDataSlotCreateInfo_handle((VkPrivateDataSlotCreateInfo *)args->pCreateInfo);
+    /* skip args->pAllocator */
+    /* skip args->pPrivateDataSlot */
+}
+
+static inline void vn_encode_vkCreatePrivateDataSlot_reply(struct vn_cs_encoder *enc, const struct vn_command_vkCreatePrivateDataSlot *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkCreatePrivateDataSlot_EXT});
+
+    vn_encode_VkResult(enc, &args->ret);
+    /* skip args->device */
+    /* skip args->pCreateInfo */
+    /* skip args->pAllocator */
+    if (vn_encode_simple_pointer(enc, args->pPrivateDataSlot))
+        vn_encode_VkPrivateDataSlot(enc, args->pPrivateDataSlot);
+}
+
+static inline void vn_decode_vkDestroyPrivateDataSlot_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkDestroyPrivateDataSlot *args)
+{
+    vn_decode_VkDevice_lookup(dec, &args->device);
+    vn_decode_VkPrivateDataSlot_lookup(dec, &args->privateDataSlot);
+    if (vn_decode_simple_pointer(dec)) {
+        vn_cs_decoder_set_fatal(dec);
+    } else {
+        args->pAllocator = NULL;
+    }
+}
+
+static inline void vn_replace_vkDestroyPrivateDataSlot_args_handle(struct vn_command_vkDestroyPrivateDataSlot *args)
+{
+    vn_replace_VkDevice_handle(&args->device);
+    vn_replace_VkPrivateDataSlot_handle(&args->privateDataSlot);
+    /* skip args->pAllocator */
+}
+
+static inline void vn_encode_vkDestroyPrivateDataSlot_reply(struct vn_cs_encoder *enc, const struct vn_command_vkDestroyPrivateDataSlot *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkDestroyPrivateDataSlot_EXT});
+
+    /* skip args->device */
+    /* skip args->privateDataSlot */
+    /* skip args->pAllocator */
+}
+
+static inline void vn_decode_vkSetPrivateData_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkSetPrivateData *args)
+{
+    vn_decode_VkDevice_lookup(dec, &args->device);
+    vn_decode_VkObjectType(dec, &args->objectType);
+    vn_decode_uint64_t(dec, &args->objectHandle);
+    vn_decode_VkPrivateDataSlot_lookup(dec, &args->privateDataSlot);
+    vn_decode_uint64_t(dec, &args->data);
+}
+
+static inline void vn_replace_vkSetPrivateData_args_handle(struct vn_command_vkSetPrivateData *args)
+{
+    vn_replace_VkDevice_handle(&args->device);
+    /* skip args->objectType */
+    /* skip args->objectHandle */
+    vn_replace_VkPrivateDataSlot_handle(&args->privateDataSlot);
+    /* skip args->data */
+}
+
+static inline void vn_encode_vkSetPrivateData_reply(struct vn_cs_encoder *enc, const struct vn_command_vkSetPrivateData *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkSetPrivateData_EXT});
+
+    vn_encode_VkResult(enc, &args->ret);
+    /* skip args->device */
+    /* skip args->objectType */
+    /* skip args->objectHandle */
+    /* skip args->privateDataSlot */
+    /* skip args->data */
+}
+
+static inline void vn_decode_vkGetPrivateData_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkGetPrivateData *args)
+{
+    vn_decode_VkDevice_lookup(dec, &args->device);
+    vn_decode_VkObjectType(dec, &args->objectType);
+    vn_decode_uint64_t(dec, &args->objectHandle);
+    vn_decode_VkPrivateDataSlot_lookup(dec, &args->privateDataSlot);
+    if (vn_decode_simple_pointer(dec)) {
+        args->pData = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pData));
+        if (!args->pData) return;
+    } else {
+        args->pData = NULL;
+        vn_cs_decoder_set_fatal(dec);
+    }
+}
+
+static inline void vn_replace_vkGetPrivateData_args_handle(struct vn_command_vkGetPrivateData *args)
+{
+    vn_replace_VkDevice_handle(&args->device);
+    /* skip args->objectType */
+    /* skip args->objectHandle */
+    vn_replace_VkPrivateDataSlot_handle(&args->privateDataSlot);
+    /* skip args->pData */
+}
+
+static inline void vn_encode_vkGetPrivateData_reply(struct vn_cs_encoder *enc, const struct vn_command_vkGetPrivateData *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkGetPrivateData_EXT});
+
+    /* skip args->device */
+    /* skip args->objectType */
+    /* skip args->objectHandle */
+    /* skip args->privateDataSlot */
+    if (vn_encode_simple_pointer(enc, args->pData))
+        vn_encode_uint64_t(enc, args->pData);
+}
+
+static inline void vn_dispatch_vkCreatePrivateDataSlot(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkCreatePrivateDataSlot args;
+
+    if (!ctx->dispatch_vkCreatePrivateDataSlot) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkCreatePrivateDataSlot_args_temp(ctx->decoder, &args);
+    if (!args.device) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkCreatePrivateDataSlot(ctx, &args);
+
+#ifdef DEBUG
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
+        vn_dispatch_debug_log(ctx, "vkCreatePrivateDataSlot returned %d", args.ret);
+#endif
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkCreatePrivateDataSlot_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
+static inline void vn_dispatch_vkDestroyPrivateDataSlot(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkDestroyPrivateDataSlot args;
+
+    if (!ctx->dispatch_vkDestroyPrivateDataSlot) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkDestroyPrivateDataSlot_args_temp(ctx->decoder, &args);
+    if (!args.device) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkDestroyPrivateDataSlot(ctx, &args);
+
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkDestroyPrivateDataSlot_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
+static inline void vn_dispatch_vkSetPrivateData(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkSetPrivateData args;
+
+    if (!ctx->dispatch_vkSetPrivateData) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkSetPrivateData_args_temp(ctx->decoder, &args);
+    if (!args.device) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkSetPrivateData(ctx, &args);
+
+#ifdef DEBUG
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
+        vn_dispatch_debug_log(ctx, "vkSetPrivateData returned %d", args.ret);
+#endif
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkSetPrivateData_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
+static inline void vn_dispatch_vkGetPrivateData(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkGetPrivateData args;
+
+    if (!ctx->dispatch_vkGetPrivateData) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkGetPrivateData_args_temp(ctx->decoder, &args);
+    if (!args.device) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkGetPrivateData(ctx, &args);
+
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkGetPrivateData_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
+#pragma GCC diagnostic pop
+
+#endif /* VN_PROTOCOL_RENDERER_PRIVATE_DATA_SLOT_H */

src/venus/venus-protocol/vn_protocol_renderer_queue.h

@@ -764,6 +764,233 @@ vn_replace_VkBindSparseInfo_handle(VkBindSparseInfo *val)
     } while (pnext);
 }
 
+/* struct VkSemaphoreSubmitInfo chain */
+
+static inline void *
+vn_decode_VkSemaphoreSubmitInfo_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkSemaphoreSubmitInfo_self_temp(struct vn_cs_decoder *dec, VkSemaphoreSubmitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkSemaphore_lookup(dec, &val->semaphore);
+    vn_decode_uint64_t(dec, &val->value);
+    vn_decode_VkFlags64(dec, &val->stageMask);
+    vn_decode_uint32_t(dec, &val->deviceIndex);
+}
+
+static inline void
+vn_decode_VkSemaphoreSubmitInfo_temp(struct vn_cs_decoder *dec, VkSemaphoreSubmitInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkSemaphoreSubmitInfo_pnext_temp(dec);
+    vn_decode_VkSemaphoreSubmitInfo_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkSemaphoreSubmitInfo_handle_self(VkSemaphoreSubmitInfo *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    vn_replace_VkSemaphore_handle(&val->semaphore);
+    /* skip val->value */
+    /* skip val->stageMask */
+    /* skip val->deviceIndex */
+}
+
+static inline void
+vn_replace_VkSemaphoreSubmitInfo_handle(VkSemaphoreSubmitInfo *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO:
+            vn_replace_VkSemaphoreSubmitInfo_handle_self((VkSemaphoreSubmitInfo *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+/* struct VkCommandBufferSubmitInfo chain */
+
+static inline void *
+vn_decode_VkCommandBufferSubmitInfo_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkCommandBufferSubmitInfo_self_temp(struct vn_cs_decoder *dec, VkCommandBufferSubmitInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkCommandBuffer_lookup(dec, &val->commandBuffer);
+    vn_decode_uint32_t(dec, &val->deviceMask);
+}
+
+static inline void
+vn_decode_VkCommandBufferSubmitInfo_temp(struct vn_cs_decoder *dec, VkCommandBufferSubmitInfo *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkCommandBufferSubmitInfo_pnext_temp(dec);
+    vn_decode_VkCommandBufferSubmitInfo_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkCommandBufferSubmitInfo_handle_self(VkCommandBufferSubmitInfo *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    vn_replace_VkCommandBuffer_handle(&val->commandBuffer);
+    /* skip val->deviceMask */
+}
+
+static inline void
+vn_replace_VkCommandBufferSubmitInfo_handle(VkCommandBufferSubmitInfo *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO:
+            vn_replace_VkCommandBufferSubmitInfo_handle_self((VkCommandBufferSubmitInfo *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
+/* struct VkSubmitInfo2 chain */
+
+static inline void *
+vn_decode_VkSubmitInfo2_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkSubmitInfo2_self_temp(struct vn_cs_decoder *dec, VkSubmitInfo2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFlags(dec, &val->flags);
+    vn_decode_uint32_t(dec, &val->waitSemaphoreInfoCount);
+    if (vn_peek_array_size(dec)) {
+        const uint32_t iter_count = vn_decode_array_size(dec, val->waitSemaphoreInfoCount);
+        val->pWaitSemaphoreInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pWaitSemaphoreInfos) * iter_count);
+        if (!val->pWaitSemaphoreInfos) return;
+        for (uint32_t i = 0; i < iter_count; i++)
+            vn_decode_VkSemaphoreSubmitInfo_temp(dec, &((VkSemaphoreSubmitInfo *)val->pWaitSemaphoreInfos)[i]);
+    } else {
+        vn_decode_array_size(dec, val->waitSemaphoreInfoCount);
+        val->pWaitSemaphoreInfos = NULL;
+    }
+    vn_decode_uint32_t(dec, &val->commandBufferInfoCount);
+    if (vn_peek_array_size(dec)) {
+        const uint32_t iter_count = vn_decode_array_size(dec, val->commandBufferInfoCount);
+        val->pCommandBufferInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pCommandBufferInfos) * iter_count);
+        if (!val->pCommandBufferInfos) return;
+        for (uint32_t i = 0; i < iter_count; i++)
+            vn_decode_VkCommandBufferSubmitInfo_temp(dec, &((VkCommandBufferSubmitInfo *)val->pCommandBufferInfos)[i]);
+    } else {
+        vn_decode_array_size(dec, val->commandBufferInfoCount);
+        val->pCommandBufferInfos = NULL;
+    }
+    vn_decode_uint32_t(dec, &val->signalSemaphoreInfoCount);
+    if (vn_peek_array_size(dec)) {
+        const uint32_t iter_count = vn_decode_array_size(dec, val->signalSemaphoreInfoCount);
+        val->pSignalSemaphoreInfos = vn_cs_decoder_alloc_temp(dec, sizeof(*val->pSignalSemaphoreInfos) * iter_count);
+        if (!val->pSignalSemaphoreInfos) return;
+        for (uint32_t i = 0; i < iter_count; i++)
+            vn_decode_VkSemaphoreSubmitInfo_temp(dec, &((VkSemaphoreSubmitInfo *)val->pSignalSemaphoreInfos)[i]);
+    } else {
+        vn_decode_array_size(dec, val->signalSemaphoreInfoCount);
+        val->pSignalSemaphoreInfos = NULL;
+    }
+}
+
+static inline void
+vn_decode_VkSubmitInfo2_temp(struct vn_cs_decoder *dec, VkSubmitInfo2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_SUBMIT_INFO_2)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkSubmitInfo2_pnext_temp(dec);
+    vn_decode_VkSubmitInfo2_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkSubmitInfo2_handle_self(VkSubmitInfo2 *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    /* skip val->flags */
+    /* skip val->waitSemaphoreInfoCount */
+    if (val->pWaitSemaphoreInfos) {
+       for (uint32_t i = 0; i < val->waitSemaphoreInfoCount; i++)
+            vn_replace_VkSemaphoreSubmitInfo_handle(&((VkSemaphoreSubmitInfo *)val->pWaitSemaphoreInfos)[i]);
+    }
+    /* skip val->commandBufferInfoCount */
+    if (val->pCommandBufferInfos) {
+       for (uint32_t i = 0; i < val->commandBufferInfoCount; i++)
+            vn_replace_VkCommandBufferSubmitInfo_handle(&((VkCommandBufferSubmitInfo *)val->pCommandBufferInfos)[i]);
+    }
+    /* skip val->signalSemaphoreInfoCount */
+    if (val->pSignalSemaphoreInfos) {
+       for (uint32_t i = 0; i < val->signalSemaphoreInfoCount; i++)
+            vn_replace_VkSemaphoreSubmitInfo_handle(&((VkSemaphoreSubmitInfo *)val->pSignalSemaphoreInfos)[i]);
+    }
+}
+
+static inline void
+vn_replace_VkSubmitInfo2_handle(VkSubmitInfo2 *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_SUBMIT_INFO_2:
+            vn_replace_VkSubmitInfo2_handle_self((VkSubmitInfo2 *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
 static inline void vn_decode_vkQueueSubmit_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkQueueSubmit *args)
 {
     vn_decode_VkQueue_lookup(dec, &args->queue);
@@ -860,6 +1087,45 @@ static inline void vn_encode_vkQueueBindSparse_reply(struct vn_cs_encoder *enc,
     /* skip args->fence */
 }
 
+static inline void vn_decode_vkQueueSubmit2_args_temp(struct vn_cs_decoder *dec, struct vn_command_vkQueueSubmit2 *args)
+{
+    vn_decode_VkQueue_lookup(dec, &args->queue);
+    vn_decode_uint32_t(dec, &args->submitCount);
+    if (vn_peek_array_size(dec)) {
+        const uint32_t iter_count = vn_decode_array_size(dec, args->submitCount);
+        args->pSubmits = vn_cs_decoder_alloc_temp(dec, sizeof(*args->pSubmits) * iter_count);
+        if (!args->pSubmits) return;
+        for (uint32_t i = 0; i < iter_count; i++)
+            vn_decode_VkSubmitInfo2_temp(dec, &((VkSubmitInfo2 *)args->pSubmits)[i]);
+    } else {
+        vn_decode_array_size(dec, args->submitCount);
+        args->pSubmits = NULL;
+    }
+    vn_decode_VkFence_lookup(dec, &args->fence);
+}
+
+static inline void vn_replace_vkQueueSubmit2_args_handle(struct vn_command_vkQueueSubmit2 *args)
+{
+    vn_replace_VkQueue_handle(&args->queue);
+    /* skip args->submitCount */
+    if (args->pSubmits) {
+       for (uint32_t i = 0; i < args->submitCount; i++)
+            vn_replace_VkSubmitInfo2_handle(&((VkSubmitInfo2 *)args->pSubmits)[i]);
+    }
+    vn_replace_VkFence_handle(&args->fence);
+}
+
+static inline void vn_encode_vkQueueSubmit2_reply(struct vn_cs_encoder *enc, const struct vn_command_vkQueueSubmit2 *args)
+{
+    vn_encode_VkCommandTypeEXT(enc, &(VkCommandTypeEXT){VK_COMMAND_TYPE_vkQueueSubmit2_EXT});
+
+    vn_encode_VkResult(enc, &args->ret);
+    /* skip args->queue */
+    /* skip args->submitCount */
+    /* skip args->pSubmits */
+    /* skip args->fence */
+}
+
 static inline void vn_dispatch_vkQueueSubmit(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
 {
     struct vn_command_vkQueueSubmit args;
@@ -947,6 +1213,35 @@ static inline void vn_dispatch_vkQueueBindSparse(struct vn_dispatch_context *ctx
     vn_cs_decoder_reset_temp_pool(ctx->decoder);
 }
 
+static inline void vn_dispatch_vkQueueSubmit2(struct vn_dispatch_context *ctx, VkCommandFlagsEXT flags)
+{
+    struct vn_command_vkQueueSubmit2 args;
+
+    if (!ctx->dispatch_vkQueueSubmit2) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    vn_decode_vkQueueSubmit2_args_temp(ctx->decoder, &args);
+    if (!args.queue) {
+        vn_cs_decoder_set_fatal(ctx->decoder);
+        return;
+    }
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder))
+        ctx->dispatch_vkQueueSubmit2(ctx, &args);
+
+#ifdef DEBUG
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && vn_dispatch_should_log_result(args.ret))
+        vn_dispatch_debug_log(ctx, "vkQueueSubmit2 returned %d", args.ret);
+#endif
+
+    if (!vn_cs_decoder_get_fatal(ctx->decoder) && (flags & VK_COMMAND_GENERATE_REPLY_BIT_EXT))
+       vn_encode_vkQueueSubmit2_reply(ctx->encoder, &args);
+
+    vn_cs_decoder_reset_temp_pool(ctx->decoder);
+}
+
 #pragma GCC diagnostic pop
 
 #endif /* VN_PROTOCOL_RENDERER_QUEUE_H */

src/venus/venus-protocol/vn_protocol_renderer_render_pass.h

@@ -1008,10 +1008,30 @@ vn_replace_VkSubpassDescription2_handle(VkSubpassDescription2 *val)
 static inline void *
 vn_decode_VkSubpassDependency2_pnext_temp(struct vn_cs_decoder *dec)
 {
-    /* no known/supported struct */
+    VkBaseOutStructure *pnext;
-    if (vn_decode_simple_pointer(dec))
+    VkStructureType stype;
+
+    if (!vn_decode_simple_pointer(dec))
+        return NULL;
+
+    vn_decode_VkStructureType(dec, &stype);
+    switch ((int32_t)stype) {
+    case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+        pnext = vn_cs_decoder_alloc_temp(dec, sizeof(VkMemoryBarrier2));
+        if (pnext) {
+            pnext->sType = stype;
+            pnext->pNext = vn_decode_VkSubpassDependency2_pnext_temp(dec);
+            vn_decode_VkMemoryBarrier2_self_temp(dec, (VkMemoryBarrier2 *)pnext);
+        }
+        break;
+    default:
+        /* unexpected struct */
+        pnext = NULL;
         vn_cs_decoder_set_fatal(dec);
-    return NULL;
+        break;
+    }
+
+    return pnext;
 }
 
 static inline void
@@ -1066,6 +1086,9 @@ vn_replace_VkSubpassDependency2_handle(VkSubpassDependency2 *val)
         case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2:
             vn_replace_VkSubpassDependency2_handle_self((VkSubpassDependency2 *)pnext);
             break;
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+            vn_replace_VkMemoryBarrier2_handle_self((VkMemoryBarrier2 *)pnext);
+            break;
         default:
             /* ignore unknown/unsupported struct */
             break;

src/venus/venus-protocol/vn_protocol_renderer_structs.h

@@ -243,6 +243,35 @@ vn_replace_VkSemaphoreTypeCreateInfo_handle(VkSemaphoreTypeCreateInfo *val)
 
 /* struct VkImageFormatListCreateInfo chain */
 
+static inline void
+vn_encode_VkImageFormatListCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageFormatListCreateInfo_self(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    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_VkImageFormatListCreateInfo(struct vn_cs_encoder *enc, const VkImageFormatListCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO });
+    vn_encode_VkImageFormatListCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageFormatListCreateInfo_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkImageFormatListCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -310,6 +339,29 @@ vn_replace_VkImageFormatListCreateInfo_handle(VkImageFormatListCreateInfo *val)
 
 /* struct VkImageStencilUsageCreateInfo chain */
 
+static inline void
+vn_encode_VkImageStencilUsageCreateInfo_pnext(struct vn_cs_encoder *enc, const void *val)
+{
+    /* no known/supported struct */
+    vn_encode_simple_pointer(enc, NULL);
+}
+
+static inline void
+vn_encode_VkImageStencilUsageCreateInfo_self(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_encode_VkFlags(enc, &val->stencilUsage);
+}
+
+static inline void
+vn_encode_VkImageStencilUsageCreateInfo(struct vn_cs_encoder *enc, const VkImageStencilUsageCreateInfo *val)
+{
+    assert(val->sType == VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO);
+    vn_encode_VkStructureType(enc, &(VkStructureType){ VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO });
+    vn_encode_VkImageStencilUsageCreateInfo_pnext(enc, val->pNext);
+    vn_encode_VkImageStencilUsageCreateInfo_self(enc, val);
+}
+
 static inline void *
 vn_decode_VkImageStencilUsageCreateInfo_pnext_temp(struct vn_cs_decoder *dec)
 {
@@ -753,6 +805,69 @@ vn_decode_VkMemoryRequirements2_partial_temp(struct vn_cs_decoder *dec, VkMemory
     vn_decode_VkMemoryRequirements2_self_partial_temp(dec, val);
 }
 
+/* struct VkMemoryBarrier2 chain */
+
+static inline void *
+vn_decode_VkMemoryBarrier2_pnext_temp(struct vn_cs_decoder *dec)
+{
+    /* no known/supported struct */
+    if (vn_decode_simple_pointer(dec))
+        vn_cs_decoder_set_fatal(dec);
+    return NULL;
+}
+
+static inline void
+vn_decode_VkMemoryBarrier2_self_temp(struct vn_cs_decoder *dec, VkMemoryBarrier2 *val)
+{
+    /* skip val->{sType,pNext} */
+    vn_decode_VkFlags64(dec, &val->srcStageMask);
+    vn_decode_VkFlags64(dec, &val->srcAccessMask);
+    vn_decode_VkFlags64(dec, &val->dstStageMask);
+    vn_decode_VkFlags64(dec, &val->dstAccessMask);
+}
+
+static inline void
+vn_decode_VkMemoryBarrier2_temp(struct vn_cs_decoder *dec, VkMemoryBarrier2 *val)
+{
+    VkStructureType stype;
+    vn_decode_VkStructureType(dec, &stype);
+    if (stype != VK_STRUCTURE_TYPE_MEMORY_BARRIER_2)
+        vn_cs_decoder_set_fatal(dec);
+
+    val->sType = stype;
+    val->pNext = vn_decode_VkMemoryBarrier2_pnext_temp(dec);
+    vn_decode_VkMemoryBarrier2_self_temp(dec, val);
+}
+
+static inline void
+vn_replace_VkMemoryBarrier2_handle_self(VkMemoryBarrier2 *val)
+{
+    /* skip val->sType */
+    /* skip val->pNext */
+    /* skip val->srcStageMask */
+    /* skip val->srcAccessMask */
+    /* skip val->dstStageMask */
+    /* skip val->dstAccessMask */
+}
+
+static inline void
+vn_replace_VkMemoryBarrier2_handle(VkMemoryBarrier2 *val)
+{
+    struct VkBaseOutStructure *pnext = (struct VkBaseOutStructure *)val;
+
+    do {
+        switch ((int32_t)pnext->sType) {
+        case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2:
+            vn_replace_VkMemoryBarrier2_handle_self((VkMemoryBarrier2 *)pnext);
+            break;
+        default:
+            /* ignore unknown/unsupported struct */
+            break;
+        }
+        pnext = pnext->pNext;
+    } while (pnext);
+}
+
 #pragma GCC diagnostic pop
 
 #endif /* VN_PROTOCOL_RENDERER_STRUCTS_H */

src/venus/venus-protocol/vn_protocol_renderer_types.h

@@ -375,6 +375,20 @@ vn_decode_VkFlags_array(struct vn_cs_decoder *dec, VkFlags *val, uint32_t count)
     vn_decode_uint32_t_array(dec, val, count);
 }
 
+/* typedef uint64_t VkFlags64 */
+
+static inline void
+vn_encode_VkFlags64(struct vn_cs_encoder *enc, const VkFlags64 *val)
+{
+    vn_encode_uint64_t(enc, val);
+}
+
+static inline void
+vn_decode_VkFlags64(struct vn_cs_decoder *dec, VkFlags64 *val)
+{
+    vn_decode_uint64_t(dec, val);
+}
+
 /* typedef uint64_t VkDeviceSize */
 
 static inline void
@@ -483,6 +497,34 @@ vn_decode_VkPipelineCacheCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineCac
     vn_decode_int32_t(dec, (int32_t *)val);
 }
 
+/* enum VkPipelineDepthStencilStateCreateFlagBits */
+
+static inline void
+vn_encode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineDepthStencilStateCreateFlagBits *val)
+{
+    vn_encode_int32_t(enc, (const int32_t *)val);
+}
+
+static inline void
+vn_decode_VkPipelineDepthStencilStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineDepthStencilStateCreateFlagBits *val)
+{
+    vn_decode_int32_t(dec, (int32_t *)val);
+}
+
+/* enum VkPipelineColorBlendStateCreateFlagBits */
+
+static inline void
+vn_encode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_encoder *enc, const VkPipelineColorBlendStateCreateFlagBits *val)
+{
+    vn_encode_int32_t(enc, (const int32_t *)val);
+}
+
+static inline void
+vn_decode_VkPipelineColorBlendStateCreateFlagBits(struct vn_cs_decoder *dec, VkPipelineColorBlendStateCreateFlagBits *val)
+{
+    vn_decode_int32_t(dec, (int32_t *)val);
+}
+
 /* enum VkPipelineShaderStageCreateFlagBits */
 
 static inline void
@@ -917,6 +959,18 @@ vn_decode_VkSampleCountFlagBits(struct vn_cs_decoder *dec, VkSampleCountFlagBits
     vn_decode_int32_t(dec, (int32_t *)val);
 }
 
+static inline void
+vn_encode_VkSampleCountFlagBits_array(struct vn_cs_encoder *enc, const VkSampleCountFlagBits *val, uint32_t count)
+{
+    vn_encode_int32_t_array(enc, (const int32_t *)val, count);
+}
+
+static inline void
+vn_decode_VkSampleCountFlagBits_array(struct vn_cs_decoder *dec, VkSampleCountFlagBits *val, uint32_t count)
+{
+    vn_decode_int32_t_array(dec, (int32_t *)val, count);
+}
+
 /* enum VkAttachmentDescriptionFlagBits */
 
 static inline void
@@ -1001,6 +1055,20 @@ vn_decode_VkSubgroupFeatureFlagBits(struct vn_cs_decoder *dec, VkSubgroupFeature
     vn_decode_int32_t(dec, (int32_t *)val);
 }
 
+/* enum VkPipelineCreationFeedbackFlagBits */
+
+static inline void
+vn_encode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_encoder *enc, const VkPipelineCreationFeedbackFlagBits *val)
+{
+    vn_encode_int32_t(enc, (const int32_t *)val);
+}
+
+static inline void
+vn_decode_VkPipelineCreationFeedbackFlagBits(struct vn_cs_decoder *dec, VkPipelineCreationFeedbackFlagBits *val)
+{
+    vn_decode_int32_t(dec, (int32_t *)val);
+}
+
 /* enum VkSemaphoreWaitFlagBits */
 
 static inline void
@@ -1015,6 +1083,62 @@ vn_decode_VkSemaphoreWaitFlagBits(struct vn_cs_decoder *dec, VkSemaphoreWaitFlag
     vn_decode_int32_t(dec, (int32_t *)val);
 }
 
+/* typedef VkFlags64 VkAccessFlagBits2 */
+
+static inline void
+vn_encode_VkAccessFlagBits2(struct vn_cs_encoder *enc, const VkAccessFlagBits2 *val)
+{
+    vn_encode_uint64_t(enc, (const uint64_t *)val);
+}
+
+static inline void
+vn_decode_VkAccessFlagBits2(struct vn_cs_decoder *dec, VkAccessFlagBits2 *val)
+{
+    vn_decode_uint64_t(dec, (uint64_t *)val);
+}
+
+/* typedef VkFlags64 VkPipelineStageFlagBits2 */
+
+static inline void
+vn_encode_VkPipelineStageFlagBits2(struct vn_cs_encoder *enc, const VkPipelineStageFlagBits2 *val)
+{
+    vn_encode_uint64_t(enc, (const uint64_t *)val);
+}
+
+static inline void
+vn_decode_VkPipelineStageFlagBits2(struct vn_cs_decoder *dec, VkPipelineStageFlagBits2 *val)
+{
+    vn_decode_uint64_t(dec, (uint64_t *)val);
+}
+
+/* typedef VkFlags64 VkFormatFeatureFlagBits2 */
+
+static inline void
+vn_encode_VkFormatFeatureFlagBits2(struct vn_cs_encoder *enc, const VkFormatFeatureFlagBits2 *val)
+{
+    vn_encode_uint64_t(enc, (const uint64_t *)val);
+}
+
+static inline void
+vn_decode_VkFormatFeatureFlagBits2(struct vn_cs_decoder *dec, VkFormatFeatureFlagBits2 *val)
+{
+    vn_decode_uint64_t(dec, (uint64_t *)val);
+}
+
+/* enum VkRenderingFlagBits */
+
+static inline void
+vn_encode_VkRenderingFlagBits(struct vn_cs_encoder *enc, const VkRenderingFlagBits *val)
+{
+    vn_encode_int32_t(enc, (const int32_t *)val);
+}
+
+static inline void
+vn_decode_VkRenderingFlagBits(struct vn_cs_decoder *dec, VkRenderingFlagBits *val)
+{
+    vn_decode_int32_t(dec, (int32_t *)val);
+}
+
 /* enum VkPeerMemoryFeatureFlagBits */
 
 static inline void
@@ -1183,6 +1307,34 @@ vn_decode_VkResolveModeFlagBits(struct vn_cs_decoder *dec, VkResolveModeFlagBits
     vn_decode_int32_t(dec, (int32_t *)val);
 }
 
+/* enum VkToolPurposeFlagBits */
+
+static inline void
+vn_encode_VkToolPurposeFlagBits(struct vn_cs_encoder *enc, const VkToolPurposeFlagBits *val)
+{
+    vn_encode_int32_t(enc, (const int32_t *)val);
+}
+
+static inline void
+vn_decode_VkToolPurposeFlagBits(struct vn_cs_decoder *dec, VkToolPurposeFlagBits *val)
+{
+    vn_decode_int32_t(dec, (int32_t *)val);
+}
+
+/* enum VkSubmitFlagBits */
+
+static inline void
+vn_encode_VkSubmitFlagBits(struct vn_cs_encoder *enc, const VkSubmitFlagBits *val)
+{
+    vn_encode_int32_t(enc, (const int32_t *)val);
+}
+
+static inline void
+vn_decode_VkSubmitFlagBits(struct vn_cs_decoder *dec, VkSubmitFlagBits *val)
+{
+    vn_decode_int32_t(dec, (int32_t *)val);
+}
+
 /* enum VkAttachmentLoadOp */
 
 static inline void

src/venus/venus-protocol/vulkan.h

@@ -2,7 +2,7 @@
 #define VULKAN_H_ 1
 
 /*
-** Copyright 2015-2021 The Khronos Group Inc.
+** Copyright 2015-2022 The Khronos Group Inc.
 **
 ** SPDX-License-Identifier: Apache-2.0
 */