Merge "Add VK_EXT_debug_utils to host modules for codegen" into main
GitOrigin-RevId: deba42cf1abacdc859fbbfa9329527c8b8299118
Change-Id: I9f1e087c917f6ed8d61e45a0eb0aba93de1a1b66
diff --git a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
index 25866cf..941af9b 100644
--- a/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
+++ b/codegen/vulkan/vulkan-docs-next/scripts/cerealgenerator.py
@@ -38,7 +38,6 @@
"VK_VERSION_1_3",
# Instance extensions
"VK_KHR_get_physical_device_properties2",
- "VK_KHR_sampler_ycbcr_conversion",
"VK_KHR_external_semaphore_capabilities",
"VK_KHR_external_memory_capabilities",
"VK_KHR_external_fence_capabilities",
@@ -113,7 +112,6 @@
"VK_EXT_tooling_info",
"VK_EXT_ycbcr_2plane_444_formats",
# Host dispatch
- "VK_EXT_debug_utils",
"VK_KHR_surface",
"VK_KHR_swapchain",
"VK_KHR_xcb_surface",
@@ -148,13 +146,13 @@
# we wish run wrappers when the module requires it. For example, `VK_GOOGLE_gfxstream`
# shouldn't generate a function table entry since it's an internal interface.
SUPPORTED_MODULES = {
- "VK_EXT_debug_utils": ["goldfish_vk_dispatch"],
+ "VK_EXT_debug_utils": HOST_MODULES,
"VK_KHR_surface": ["goldfish_vk_dispatch"],
"VK_KHR_xcb_surface": ["goldfish_vk_dispatch"],
"VK_KHR_win32_surface": ["goldfish_vk_dispatch"],
"VK_EXT_metal_surface": ["goldfish_vk_dispatch"],
# VK_MVK_moltenvk doesn't generate a generate dispatch entry for some reason, but should. The
- # lack of this extension doesn't cause any build failtures though.
+ # lack of this extension doesn't cause any build failures though.
"VK_MVK_moltenvk": ["goldfish_vk_dispatch"],
"VK_KHR_external_semaphore_win32" : ["goldfish_vk_dispatch"],
"VK_KHR_external_memory_win32" : ["goldfish_vk_dispatch"],
diff --git a/guest/vulkan_enc/func_table.cpp b/guest/vulkan_enc/func_table.cpp
index 4dcfcc4..f3632ca 100644
--- a/guest/vulkan_enc/func_table.cpp
+++ b/guest/vulkan_enc/func_table.cpp
@@ -34,6 +34,7 @@
#include <cstring>
+#include "../OpenglSystemCommon/HostConnection.h"
#include "ResourceTracker.h"
#include "VkEncoder.h"
#include "gfxstream_vk_entrypoints.h"
diff --git a/host/vulkan/VkDecoder.cpp b/host/vulkan/VkDecoder.cpp
index 8e965de..ec4208f 100644
--- a/host/vulkan/VkDecoder.cpp
+++ b/host/vulkan/VkDecoder.cpp
@@ -18275,6 +18275,532 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+ case OP_vkSetDebugUtilsObjectNameEXT: {
+ android::base::beginTrace("vkSetDebugUtilsObjectNameEXT decode");
+ VkDevice device;
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo;
+ // Begin non wrapped dispatchable handle unboxing for device;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+ auto unboxed_device = unbox_VkDevice(device);
+ auto vk = dispatch_VkDevice(device);
+ // End manual dispatchable handle unboxing for device;
+ vkReadStream->alloc((void**)&pNameInfo,
+ sizeof(const VkDebugUtilsObjectNameInfoEXT));
+ reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsObjectNameInfoEXT*)(pNameInfo), readStreamPtrPtr);
+ if (pNameInfo) {
+ transform_tohost_VkDebugUtilsObjectNameInfoEXT(
+ m_state, (VkDebugUtilsObjectNameInfoEXT*)(pNameInfo));
+ }
+ if (m_logCalls) {
+ fprintf(stderr, "stream %p: call vkSetDebugUtilsObjectNameEXT 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)device, (unsigned long long)pNameInfo);
+ }
+ VkResult vkSetDebugUtilsObjectNameEXT_VkResult_return = (VkResult)0;
+ vkSetDebugUtilsObjectNameEXT_VkResult_return =
+ vk->vkSetDebugUtilsObjectNameEXT(unboxed_device, pNameInfo);
+ if ((vkSetDebugUtilsObjectNameEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+ m_state->on_DeviceLost();
+ m_state->on_CheckOutOfMemory(vkSetDebugUtilsObjectNameEXT_VkResult_return, opcode,
+ context);
+ vkStream->unsetHandleMapping();
+ vkStream->write(&vkSetDebugUtilsObjectNameEXT_VkResult_return, sizeof(VkResult));
+ vkStream->commitWrite();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkSetDebugUtilsObjectNameEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+ vkSetDebugUtilsObjectNameEXT_VkResult_return, device, pNameInfo);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkSetDebugUtilsObjectTagEXT: {
+ android::base::beginTrace("vkSetDebugUtilsObjectTagEXT decode");
+ VkDevice device;
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo;
+ // Begin non wrapped dispatchable handle unboxing for device;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkDevice*)&device = (VkDevice)(VkDevice)((VkDevice)(*&cgen_var_0));
+ auto unboxed_device = unbox_VkDevice(device);
+ auto vk = dispatch_VkDevice(device);
+ // End manual dispatchable handle unboxing for device;
+ vkReadStream->alloc((void**)&pTagInfo, sizeof(const VkDebugUtilsObjectTagInfoEXT));
+ reservedunmarshal_VkDebugUtilsObjectTagInfoEXT(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsObjectTagInfoEXT*)(pTagInfo), readStreamPtrPtr);
+ if (pTagInfo) {
+ transform_tohost_VkDebugUtilsObjectTagInfoEXT(
+ m_state, (VkDebugUtilsObjectTagInfoEXT*)(pTagInfo));
+ }
+ if (m_logCalls) {
+ fprintf(stderr, "stream %p: call vkSetDebugUtilsObjectTagEXT 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)device, (unsigned long long)pTagInfo);
+ }
+ VkResult vkSetDebugUtilsObjectTagEXT_VkResult_return = (VkResult)0;
+ vkSetDebugUtilsObjectTagEXT_VkResult_return =
+ vk->vkSetDebugUtilsObjectTagEXT(unboxed_device, pTagInfo);
+ if ((vkSetDebugUtilsObjectTagEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+ m_state->on_DeviceLost();
+ m_state->on_CheckOutOfMemory(vkSetDebugUtilsObjectTagEXT_VkResult_return, opcode,
+ context);
+ vkStream->unsetHandleMapping();
+ vkStream->write(&vkSetDebugUtilsObjectTagEXT_VkResult_return, sizeof(VkResult));
+ vkStream->commitWrite();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkSetDebugUtilsObjectTagEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+ vkSetDebugUtilsObjectTagEXT_VkResult_return, device, pTagInfo);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkQueueBeginDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkQueueBeginDebugUtilsLabelEXT decode");
+ VkQueue queue;
+ const VkDebugUtilsLabelEXT* pLabelInfo;
+ // Begin non wrapped dispatchable handle unboxing for queue;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
+ auto unboxed_queue = unbox_VkQueue(queue);
+ auto vk = dispatch_VkQueue(queue);
+ // End manual dispatchable handle unboxing for queue;
+ vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
+ reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo),
+ readStreamPtrPtr);
+ if (pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(m_state,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkQueueBeginDebugUtilsLabelEXT 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)queue, (unsigned long long)pLabelInfo);
+ }
+ vk->vkQueueBeginDebugUtilsLabelEXT(unboxed_queue, pLabelInfo);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkQueueBeginDebugUtilsLabelEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, pLabelInfo);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkQueueEndDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkQueueEndDebugUtilsLabelEXT decode");
+ VkQueue queue;
+ // Begin non wrapped dispatchable handle unboxing for queue;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
+ auto unboxed_queue = unbox_VkQueue(queue);
+ auto vk = dispatch_VkQueue(queue);
+ // End manual dispatchable handle unboxing for queue;
+ if (m_logCalls) {
+ fprintf(stderr, "stream %p: call vkQueueEndDebugUtilsLabelEXT 0x%llx \n",
+ ioStream, (unsigned long long)queue);
+ }
+ vk->vkQueueEndDebugUtilsLabelEXT(unboxed_queue);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkQueueEndDebugUtilsLabelEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkQueueInsertDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkQueueInsertDebugUtilsLabelEXT decode");
+ VkQueue queue;
+ const VkDebugUtilsLabelEXT* pLabelInfo;
+ // Begin non wrapped dispatchable handle unboxing for queue;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkQueue*)&queue = (VkQueue)(VkQueue)((VkQueue)(*&cgen_var_0));
+ auto unboxed_queue = unbox_VkQueue(queue);
+ auto vk = dispatch_VkQueue(queue);
+ // End manual dispatchable handle unboxing for queue;
+ vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
+ reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo),
+ readStreamPtrPtr);
+ if (pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(m_state,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkQueueInsertDebugUtilsLabelEXT 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)queue, (unsigned long long)pLabelInfo);
+ }
+ vk->vkQueueInsertDebugUtilsLabelEXT(unboxed_queue, pLabelInfo);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkQueueInsertDebugUtilsLabelEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, queue, pLabelInfo);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdBeginDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkCmdBeginDebugUtilsLabelEXT decode");
+ VkCommandBuffer commandBuffer;
+ const VkDebugUtilsLabelEXT* pLabelInfo;
+ // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkCommandBuffer*)&commandBuffer =
+ (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+ auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+ auto vk = dispatch_VkCommandBuffer(commandBuffer);
+ // End manual dispatchable handle unboxing for commandBuffer;
+ vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
+ reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo),
+ readStreamPtrPtr);
+ if (pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(m_state,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo));
+ }
+ if (m_logCalls) {
+ fprintf(stderr, "stream %p: call vkCmdBeginDebugUtilsLabelEXT 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)commandBuffer,
+ (unsigned long long)pLabelInfo);
+ }
+ vk->vkCmdBeginDebugUtilsLabelEXT(unboxed_commandBuffer, pLabelInfo);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCmdBeginDebugUtilsLabelEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pLabelInfo);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdEndDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkCmdEndDebugUtilsLabelEXT decode");
+ VkCommandBuffer commandBuffer;
+ // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkCommandBuffer*)&commandBuffer =
+ (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+ auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+ auto vk = dispatch_VkCommandBuffer(commandBuffer);
+ // End manual dispatchable handle unboxing for commandBuffer;
+ if (m_logCalls) {
+ fprintf(stderr, "stream %p: call vkCmdEndDebugUtilsLabelEXT 0x%llx \n",
+ ioStream, (unsigned long long)commandBuffer);
+ }
+ vk->vkCmdEndDebugUtilsLabelEXT(unboxed_commandBuffer);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCmdEndDebugUtilsLabelEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdInsertDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkCmdInsertDebugUtilsLabelEXT decode");
+ VkCommandBuffer commandBuffer;
+ const VkDebugUtilsLabelEXT* pLabelInfo;
+ // Begin non wrapped dispatchable handle unboxing for commandBuffer;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkCommandBuffer*)&commandBuffer =
+ (VkCommandBuffer)(VkCommandBuffer)((VkCommandBuffer)(*&cgen_var_0));
+ auto unboxed_commandBuffer = unbox_VkCommandBuffer(commandBuffer);
+ auto vk = dispatch_VkCommandBuffer(commandBuffer);
+ // End manual dispatchable handle unboxing for commandBuffer;
+ vkReadStream->alloc((void**)&pLabelInfo, sizeof(const VkDebugUtilsLabelEXT));
+ reservedunmarshal_VkDebugUtilsLabelEXT(vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo),
+ readStreamPtrPtr);
+ if (pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(m_state,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkCmdInsertDebugUtilsLabelEXT 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)commandBuffer,
+ (unsigned long long)pLabelInfo);
+ }
+ vk->vkCmdInsertDebugUtilsLabelEXT(unboxed_commandBuffer, pLabelInfo);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCmdInsertDebugUtilsLabelEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, commandBuffer, pLabelInfo);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCreateDebugUtilsMessengerEXT: {
+ android::base::beginTrace("vkCreateDebugUtilsMessengerEXT decode");
+ VkInstance instance;
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo;
+ const VkAllocationCallbacks* pAllocator;
+ VkDebugUtilsMessengerEXT* pMessenger;
+ // Begin non wrapped dispatchable handle unboxing for instance;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
+ auto unboxed_instance = unbox_VkInstance(instance);
+ auto vk = dispatch_VkInstance(instance);
+ // End manual dispatchable handle unboxing for instance;
+ vkReadStream->alloc((void**)&pCreateInfo,
+ sizeof(const VkDebugUtilsMessengerCreateInfoEXT));
+ reservedunmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsMessengerCreateInfoEXT*)(pCreateInfo), readStreamPtrPtr);
+ // WARNING PTR CHECK
+ memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+ *readStreamPtrPtr += 8;
+ if (pAllocator) {
+ vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+ reservedunmarshal_VkAllocationCallbacks(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+ }
+ // Begin manual dispatchable handle unboxing for pMessenger;
+ vkReadStream->unsetHandleMapping();
+ vkReadStream->alloc((void**)&pMessenger, sizeof(VkDebugUtilsMessengerEXT));
+ uint64_t cgen_var_2;
+ memcpy((uint64_t*)&cgen_var_2, *readStreamPtrPtr, 8);
+ *readStreamPtrPtr += 8;
+ *(VkDebugUtilsMessengerEXT*)pMessenger =
+ (VkDebugUtilsMessengerEXT)(VkDebugUtilsMessengerEXT)((
+ VkDebugUtilsMessengerEXT)(*&cgen_var_2));
+ if (pCreateInfo) {
+ transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
+ m_state, (VkDebugUtilsMessengerCreateInfoEXT*)(pCreateInfo));
+ }
+ if (pAllocator) {
+ transform_tohost_VkAllocationCallbacks(m_state,
+ (VkAllocationCallbacks*)(pAllocator));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkCreateDebugUtilsMessengerEXT 0x%llx 0x%llx 0x%llx "
+ "0x%llx \n",
+ ioStream, (unsigned long long)instance, (unsigned long long)pCreateInfo,
+ (unsigned long long)pAllocator, (unsigned long long)pMessenger);
+ }
+ VkResult vkCreateDebugUtilsMessengerEXT_VkResult_return = (VkResult)0;
+ vkCreateDebugUtilsMessengerEXT_VkResult_return = vk->vkCreateDebugUtilsMessengerEXT(
+ unboxed_instance, pCreateInfo, pAllocator, pMessenger);
+ if ((vkCreateDebugUtilsMessengerEXT_VkResult_return) == VK_ERROR_DEVICE_LOST)
+ m_state->on_DeviceLost();
+ m_state->on_CheckOutOfMemory(vkCreateDebugUtilsMessengerEXT_VkResult_return, opcode,
+ context);
+ vkStream->unsetHandleMapping();
+ // Begin auto non dispatchable handle create for pMessenger;
+ if (vkCreateDebugUtilsMessengerEXT_VkResult_return == VK_SUCCESS)
+ vkStream->setHandleMapping(&m_boxedHandleCreateMapping);
+ uint64_t cgen_var_3;
+ static_assert(
+ 8 == sizeof(VkDebugUtilsMessengerEXT),
+ "handle map overwrite requires VkDebugUtilsMessengerEXT to be 8 bytes long");
+ vkStream->handleMapping()->mapHandles_VkDebugUtilsMessengerEXT(
+ (VkDebugUtilsMessengerEXT*)pMessenger, 1);
+ vkStream->write((VkDebugUtilsMessengerEXT*)pMessenger, 8 * 1);
+ // Begin auto non dispatchable handle create for pMessenger;
+ vkStream->setHandleMapping(&m_boxedHandleUnwrapMapping);
+ vkStream->write(&vkCreateDebugUtilsMessengerEXT_VkResult_return, sizeof(VkResult));
+ vkStream->commitWrite();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkCreateDebugUtilsMessengerEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool,
+ vkCreateDebugUtilsMessengerEXT_VkResult_return, instance, pCreateInfo,
+ pAllocator, pMessenger);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkDestroyDebugUtilsMessengerEXT: {
+ android::base::beginTrace("vkDestroyDebugUtilsMessengerEXT decode");
+ VkInstance instance;
+ VkDebugUtilsMessengerEXT messenger;
+ const VkAllocationCallbacks* pAllocator;
+ // Begin non wrapped dispatchable handle unboxing for instance;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
+ auto unboxed_instance = unbox_VkInstance(instance);
+ auto vk = dispatch_VkInstance(instance);
+ // End manual dispatchable handle unboxing for instance;
+ // Begin manual non dispatchable handle destroy unboxing for messenger;
+ VkDebugUtilsMessengerEXT boxed_messenger_preserve;
+ uint64_t cgen_var_1;
+ memcpy((uint64_t*)&cgen_var_1, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkDebugUtilsMessengerEXT*)&messenger =
+ (VkDebugUtilsMessengerEXT)(VkDebugUtilsMessengerEXT)((
+ VkDebugUtilsMessengerEXT)(*&cgen_var_1));
+ boxed_messenger_preserve = messenger;
+ messenger = unbox_VkDebugUtilsMessengerEXT(messenger);
+ // WARNING PTR CHECK
+ memcpy((VkAllocationCallbacks**)&pAllocator, (*readStreamPtrPtr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&pAllocator);
+ *readStreamPtrPtr += 8;
+ if (pAllocator) {
+ vkReadStream->alloc((void**)&pAllocator, sizeof(const VkAllocationCallbacks));
+ reservedunmarshal_VkAllocationCallbacks(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkAllocationCallbacks*)(pAllocator), readStreamPtrPtr);
+ }
+ if (pAllocator) {
+ transform_tohost_VkAllocationCallbacks(m_state,
+ (VkAllocationCallbacks*)(pAllocator));
+ }
+ if (m_logCalls) {
+ fprintf(
+ stderr,
+ "stream %p: call vkDestroyDebugUtilsMessengerEXT 0x%llx 0x%llx 0x%llx \n",
+ ioStream, (unsigned long long)instance, (unsigned long long)messenger,
+ (unsigned long long)pAllocator);
+ }
+ vk->vkDestroyDebugUtilsMessengerEXT(unboxed_instance, messenger, pAllocator);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkDestroyDebugUtilsMessengerEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, instance,
+ boxed_messenger_preserve, pAllocator);
+ }
+ delete_VkDebugUtilsMessengerEXT(boxed_messenger_preserve);
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkSubmitDebugUtilsMessageEXT: {
+ android::base::beginTrace("vkSubmitDebugUtilsMessageEXT decode");
+ VkInstance instance;
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity;
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes;
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData;
+ // Begin non wrapped dispatchable handle unboxing for instance;
+ uint64_t cgen_var_0;
+ memcpy((uint64_t*)&cgen_var_0, *readStreamPtrPtr, 1 * 8);
+ *readStreamPtrPtr += 1 * 8;
+ *(VkInstance*)&instance = (VkInstance)(VkInstance)((VkInstance)(*&cgen_var_0));
+ auto unboxed_instance = unbox_VkInstance(instance);
+ auto vk = dispatch_VkInstance(instance);
+ // End manual dispatchable handle unboxing for instance;
+ memcpy((VkDebugUtilsMessageSeverityFlagBitsEXT*)&messageSeverity, *readStreamPtrPtr,
+ sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT));
+ *readStreamPtrPtr += sizeof(VkDebugUtilsMessageSeverityFlagBitsEXT);
+ memcpy((VkDebugUtilsMessageTypeFlagsEXT*)&messageTypes, *readStreamPtrPtr,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ *readStreamPtrPtr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
+ vkReadStream->alloc((void**)&pCallbackData,
+ sizeof(const VkDebugUtilsMessengerCallbackDataEXT));
+ reservedunmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ vkReadStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsMessengerCallbackDataEXT*)(pCallbackData), readStreamPtrPtr);
+ if (pCallbackData) {
+ transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(
+ m_state, (VkDebugUtilsMessengerCallbackDataEXT*)(pCallbackData));
+ }
+ if (m_logCalls) {
+ fprintf(stderr,
+ "stream %p: call vkSubmitDebugUtilsMessageEXT 0x%llx 0x%llx 0x%llx "
+ "0x%llx \n",
+ ioStream, (unsigned long long)instance,
+ (unsigned long long)messageSeverity, (unsigned long long)messageTypes,
+ (unsigned long long)pCallbackData);
+ }
+ vk->vkSubmitDebugUtilsMessageEXT(unboxed_instance, messageSeverity, messageTypes,
+ pCallbackData);
+ vkStream->unsetHandleMapping();
+ vkReadStream->setReadPos((uintptr_t)(*readStreamPtrPtr) -
+ (uintptr_t)snapshotTraceBegin);
+ size_t snapshotTraceBytes = vkReadStream->endTrace();
+ if (m_state->snapshotsEnabled()) {
+ m_state->snapshot()->vkSubmitDebugUtilsMessageEXT(
+ snapshotTraceBegin, snapshotTraceBytes, &m_pool, instance, messageSeverity,
+ messageTypes, pCallbackData);
+ }
+ vkReadStream->clearPool();
+ if (queueSubmitWithCommandsEnabled)
+ seqnoPtr->fetch_add(1, std::memory_order_seq_cst);
+ android::base::endTrace();
+ break;
+ }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
diff --git a/host/vulkan/VkDecoderSnapshot.cpp b/host/vulkan/VkDecoderSnapshot.cpp
index a51c873..9716272 100644
--- a/host/vulkan/VkDecoderSnapshot.cpp
+++ b/host/vulkan/VkDecoderSnapshot.cpp
@@ -1906,6 +1906,60 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+ void vkSetDebugUtilsObjectNameEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkResult input_result,
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {}
+ void vkSetDebugUtilsObjectTagEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkResult input_result,
+ VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {}
+ void vkQueueBeginDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {}
+ void vkQueueEndDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkQueue queue) {}
+ void vkQueueInsertDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) {}
+ void vkCmdBeginDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {}
+ void vkCmdEndDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer) {}
+ void vkCmdInsertDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {}
+ void vkCreateDebugUtilsMessengerEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger) {
+ android::base::AutoLock lock(mLock);
+ // pMessenger create
+ mReconstruction.addHandles((const uint64_t*)pMessenger, 1);
+ if (!pMessenger) return;
+ auto apiHandle = mReconstruction.createApiInfo();
+ auto apiInfo = mReconstruction.getApiInfo(apiHandle);
+ mReconstruction.setApiTrace(apiInfo, OP_vkCreateDebugUtilsMessengerEXT, snapshotTraceBegin,
+ snapshotTraceBytes);
+ mReconstruction.forEachHandleAddApi((const uint64_t*)pMessenger, 1, apiHandle);
+ mReconstruction.setCreatedHandlesForApi(apiHandle, (const uint64_t*)pMessenger, 1);
+ }
+ void vkDestroyDebugUtilsMessengerEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkInstance instance, VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator) {
+ android::base::AutoLock lock(mLock);
+ // messenger destroy
+ mReconstruction.removeHandles((const uint64_t*)(&messenger), 1);
+ }
+ void vkSubmitDebugUtilsMessageEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {}
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
@@ -5093,6 +5147,110 @@
counterBufferOffset, counterOffset, vertexStride);
}
#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkSetDebugUtilsObjectNameEXT(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
+ mImpl->vkSetDebugUtilsObjectNameEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+ device, pNameInfo);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkSetDebugUtilsObjectTagEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkResult input_result, VkDevice device,
+ const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
+ mImpl->vkSetDebugUtilsObjectTagEXT(snapshotTraceBegin, snapshotTraceBytes, pool, input_result,
+ device, pTagInfo);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkQueueBeginDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
+ mImpl->vkQueueBeginDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, queue,
+ pLabelInfo);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkQueueEndDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkQueue queue) {
+ mImpl->vkQueueEndDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, queue);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkQueueInsertDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkQueue queue,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
+ mImpl->vkQueueInsertDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, queue,
+ pLabelInfo);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkCmdBeginDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
+ mImpl->vkCmdBeginDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer,
+ pLabelInfo);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkCmdEndDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer) {
+ mImpl->vkCmdEndDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool, commandBuffer);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkCmdInsertDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo) {
+ mImpl->vkCmdInsertDebugUtilsLabelEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+ commandBuffer, pLabelInfo);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkCreateDebugUtilsMessengerEXT(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger) {
+ mImpl->vkCreateDebugUtilsMessengerEXT(snapshotTraceBegin, snapshotTraceBytes, pool,
+ input_result, instance, pCreateInfo, pAllocator,
+ pMessenger);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkDestroyDebugUtilsMessengerEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes,
+ android::base::BumpPool* pool,
+ VkInstance instance,
+ VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator) {
+ mImpl->vkDestroyDebugUtilsMessengerEXT(snapshotTraceBegin, snapshotTraceBytes, pool, instance,
+ messenger, pAllocator);
+}
+#endif
+#ifdef VK_EXT_debug_utils
+void VkDecoderSnapshot::vkSubmitDebugUtilsMessageEXT(
+ const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) {
+ mImpl->vkSubmitDebugUtilsMessageEXT(snapshotTraceBegin, snapshotTraceBytes, pool, instance,
+ messageSeverity, messageTypes, pCallbackData);
+}
+#endif
#ifdef VK_EXT_tooling_info
void VkDecoderSnapshot::vkGetPhysicalDeviceToolPropertiesEXT(
const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes, android::base::BumpPool* pool,
diff --git a/host/vulkan/VkDecoderSnapshot.h b/host/vulkan/VkDecoderSnapshot.h
index 8d8783b..308d81a 100644
--- a/host/vulkan/VkDecoderSnapshot.h
+++ b/host/vulkan/VkDecoderSnapshot.h
@@ -1322,6 +1322,44 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+ void vkSetDebugUtilsObjectNameEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkResult input_result,
+ VkDevice device,
+ const VkDebugUtilsObjectNameInfoEXT* pNameInfo);
+ void vkSetDebugUtilsObjectTagEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkResult input_result,
+ VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);
+ void vkQueueBeginDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+ void vkQueueEndDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkQueue queue);
+ void vkQueueInsertDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);
+ void vkCmdBeginDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ void vkCmdEndDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer);
+ void vkCmdInsertDebugUtilsLabelEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkCommandBuffer commandBuffer,
+ const VkDebugUtilsLabelEXT* pLabelInfo);
+ void vkCreateDebugUtilsMessengerEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkResult input_result, VkInstance instance,
+ const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDebugUtilsMessengerEXT* pMessenger);
+ void vkDestroyDebugUtilsMessengerEXT(const uint8_t* snapshotTraceBegin,
+ size_t snapshotTraceBytes, android::base::BumpPool* pool,
+ VkInstance instance, VkDebugUtilsMessengerEXT messenger,
+ const VkAllocationCallbacks* pAllocator);
+ void vkSubmitDebugUtilsMessageEXT(const uint8_t* snapshotTraceBegin, size_t snapshotTraceBytes,
+ android::base::BumpPool* pool, VkInstance instance,
+ VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+ VkDebugUtilsMessageTypeFlagsEXT messageTypes,
+ const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
diff --git a/host/vulkan/VkSubDecoder.cpp b/host/vulkan/VkSubDecoder.cpp
index c89cd81..771fc1e 100644
--- a/host/vulkan/VkSubDecoder.cpp
+++ b/host/vulkan/VkSubDecoder.cpp
@@ -2731,6 +2731,44 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+ case OP_vkCmdBeginDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkCmdBeginDebugUtilsLabelEXT subdecode");
+ const VkDebugUtilsLabelEXT* pLabelInfo;
+ VkDebugUtilsLabelEXT stack_pLabelInfo[1];
+ pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
+ reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo),
+ readStreamPtrPtr);
+ if (pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(globalstate,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo));
+ }
+ vk->vkCmdBeginDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdEndDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkCmdEndDebugUtilsLabelEXT subdecode");
+ vk->vkCmdEndDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle);
+ android::base::endTrace();
+ break;
+ }
+ case OP_vkCmdInsertDebugUtilsLabelEXT: {
+ android::base::beginTrace("vkCmdInsertDebugUtilsLabelEXT subdecode");
+ const VkDebugUtilsLabelEXT* pLabelInfo;
+ VkDebugUtilsLabelEXT stack_pLabelInfo[1];
+ pLabelInfo = (VkDebugUtilsLabelEXT*)stack_pLabelInfo;
+ reservedunmarshal_VkDebugUtilsLabelEXT(readStream, VK_STRUCTURE_TYPE_MAX_ENUM,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo),
+ readStreamPtrPtr);
+ if (pLabelInfo) {
+ transform_tohost_VkDebugUtilsLabelEXT(globalstate,
+ (VkDebugUtilsLabelEXT*)(pLabelInfo));
+ }
+ vk->vkCmdInsertDebugUtilsLabelEXT((VkCommandBuffer)dispatchHandle, pLabelInfo);
+ android::base::endTrace();
+ break;
+ }
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
index 60e5411..fd58d3d 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.cpp
@@ -7655,6 +7655,177 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void deepcopy_VkDebugUtilsLabelEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* from, VkDebugUtilsLabelEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pLabelName = nullptr;
+ if (from->pLabelName) {
+ to->pLabelName = alloc->strDup(from->pLabelName);
+ }
+ memcpy(to->color, from->color, 4 * sizeof(float));
+}
+
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* from,
+ VkDebugUtilsObjectNameInfoEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pObjectName = nullptr;
+ if (from->pObjectName) {
+ to->pObjectName = alloc->strDup(from->pObjectName);
+ }
+}
+
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* from,
+ VkDebugUtilsMessengerCallbackDataEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pMessageIdName = nullptr;
+ if (from->pMessageIdName) {
+ to->pMessageIdName = alloc->strDup(from->pMessageIdName);
+ }
+ to->pMessage = nullptr;
+ if (from->pMessage) {
+ to->pMessage = alloc->strDup(from->pMessage);
+ }
+ if (from) {
+ to->pQueueLabels = nullptr;
+ if (from->pQueueLabels) {
+ to->pQueueLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(
+ from->queueLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+ to->queueLabelCount = from->queueLabelCount;
+ for (uint32_t i = 0; i < (uint32_t)from->queueLabelCount; ++i) {
+ deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pQueueLabels + i,
+ (VkDebugUtilsLabelEXT*)(to->pQueueLabels + i));
+ }
+ }
+ }
+ if (from) {
+ to->pCmdBufLabels = nullptr;
+ if (from->pCmdBufLabels) {
+ to->pCmdBufLabels = (VkDebugUtilsLabelEXT*)alloc->alloc(
+ from->cmdBufLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+ to->cmdBufLabelCount = from->cmdBufLabelCount;
+ for (uint32_t i = 0; i < (uint32_t)from->cmdBufLabelCount; ++i) {
+ deepcopy_VkDebugUtilsLabelEXT(alloc, rootType, from->pCmdBufLabels + i,
+ (VkDebugUtilsLabelEXT*)(to->pCmdBufLabels + i));
+ }
+ }
+ }
+ if (from) {
+ to->pObjects = nullptr;
+ if (from->pObjects) {
+ to->pObjects = (VkDebugUtilsObjectNameInfoEXT*)alloc->alloc(
+ from->objectCount * sizeof(const VkDebugUtilsObjectNameInfoEXT));
+ to->objectCount = from->objectCount;
+ for (uint32_t i = 0; i < (uint32_t)from->objectCount; ++i) {
+ deepcopy_VkDebugUtilsObjectNameInfoEXT(
+ alloc, rootType, from->pObjects + i,
+ (VkDebugUtilsObjectNameInfoEXT*)(to->pObjects + i));
+ }
+ }
+ }
+}
+
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* from,
+ VkDebugUtilsMessengerCreateInfoEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pUserData = nullptr;
+ if (from->pUserData) {
+ to->pUserData = (void*)alloc->dupArray(from->pUserData, sizeof(uint8_t));
+ }
+}
+
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* from,
+ VkDebugUtilsObjectTagInfoEXT* to) {
+ (void)alloc;
+ (void)rootType;
+ *to = *from;
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = from->sType;
+ }
+ const void* from_pNext = from;
+ size_t pNext_size = 0u;
+ while (!pNext_size && from_pNext) {
+ from_pNext = static_cast<const vk_struct_common*>(from_pNext)->pNext;
+ pNext_size = goldfish_vk_extension_struct_size(rootType, from_pNext);
+ }
+ to->pNext = nullptr;
+ if (pNext_size) {
+ to->pNext = (void*)alloc->alloc(pNext_size);
+ deepcopy_extension_struct(alloc, rootType, from_pNext, (void*)(to->pNext));
+ }
+ to->pTag = nullptr;
+ if (from->pTag) {
+ to->pTag = (void*)alloc->dupArray(from->pTag, from->tagSize * sizeof(const uint8_t));
+ }
+}
+
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
@@ -9998,6 +10169,22 @@
break;
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ deepcopy_VkDebugUtilsObjectNameInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(structExtension),
+ reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ deepcopy_VkDebugUtilsMessengerCreateInfoEXT(
+ alloc, rootType,
+ reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension),
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
deepcopy_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
index 19cf402..114bfc7 100644
--- a/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
+++ b/host/vulkan/cereal/common/goldfish_vk_deepcopy.h
@@ -1694,6 +1694,25 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void deepcopy_VkDebugUtilsLabelEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* from, VkDebugUtilsLabelEXT* to);
+
+void deepcopy_VkDebugUtilsObjectNameInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* from,
+ VkDebugUtilsObjectNameInfoEXT* to);
+
+void deepcopy_VkDebugUtilsMessengerCallbackDataEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* from,
+ VkDebugUtilsMessengerCallbackDataEXT* to);
+
+void deepcopy_VkDebugUtilsMessengerCreateInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* from,
+ VkDebugUtilsMessengerCreateInfoEXT* to);
+
+void deepcopy_VkDebugUtilsObjectTagInfoEXT(Allocator* alloc, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* from,
+ VkDebugUtilsObjectTagInfoEXT* to);
+
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
diff --git a/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp b/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
index 6ba7ee4..beb8ae6 100644
--- a/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_extension_structs.cpp
@@ -637,6 +637,14 @@
return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ return sizeof(VkDebugUtilsObjectNameInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
@@ -1281,6 +1289,14 @@
return sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT);
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ return sizeof(VkDebugUtilsObjectNameInfoEXT);
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ return sizeof(VkDebugUtilsMessengerCreateInfoEXT);
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
return sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT);
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
index 94abfa4..c02a288 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.cpp
@@ -15515,6 +15515,316 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void marshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->putString(forMarshaling->pLabelName);
+ vkStream->write((float*)forMarshaling->color, 4 * sizeof(float));
+}
+
+void unmarshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsLabelEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pLabelName);
+ vkStream->read((float*)forUnmarshaling->color, 4 * sizeof(float));
+}
+
+void marshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
+ vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pObjectName;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pObjectName) {
+ vkStream->putString(forMarshaling->pObjectName);
+ }
+ } else {
+ vkStream->putString(forMarshaling->pObjectName);
+ }
+}
+
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
+ vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+ // WARNING PTR CHECK
+ forUnmarshaling->pObjectName = (const char*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pObjectName) {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+ }
+ } else {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pObjectName);
+ }
+}
+
+void marshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+ // WARNING PTR CHECK
+ uint64_t cgen_var_0 = (uint64_t)(uintptr_t)forMarshaling->pMessageIdName;
+ vkStream->putBe64(cgen_var_0);
+ if (forMarshaling->pMessageIdName) {
+ vkStream->putString(forMarshaling->pMessageIdName);
+ }
+ } else {
+ vkStream->putString(forMarshaling->pMessageIdName);
+ }
+ vkStream->write((int32_t*)&forMarshaling->messageIdNumber, sizeof(int32_t));
+ vkStream->putString(forMarshaling->pMessage);
+ vkStream->write((uint32_t*)&forMarshaling->queueLabelCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->queueLabelCount; ++i) {
+ marshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (const VkDebugUtilsLabelEXT*)(forMarshaling->pQueueLabels + i));
+ }
+ }
+ vkStream->write((uint32_t*)&forMarshaling->cmdBufLabelCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->cmdBufLabelCount; ++i) {
+ marshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType,
+ (const VkDebugUtilsLabelEXT*)(forMarshaling->pCmdBufLabels + i));
+ }
+ }
+ vkStream->write((uint32_t*)&forMarshaling->objectCount, sizeof(uint32_t));
+ if (forMarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forMarshaling->objectCount; ++i) {
+ marshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType,
+ (const VkDebugUtilsObjectNameInfoEXT*)(forMarshaling->pObjects + i));
+ }
+ }
+}
+
+void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+ // WARNING PTR CHECK
+ forUnmarshaling->pMessageIdName = (const char*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pMessageIdName) {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
+ }
+ } else {
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessageIdName);
+ }
+ vkStream->read((int32_t*)&forUnmarshaling->messageIdNumber, sizeof(int32_t));
+ vkStream->loadStringInPlace((char**)&forUnmarshaling->pMessage);
+ vkStream->read((uint32_t*)&forUnmarshaling->queueLabelCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pQueueLabels,
+ forUnmarshaling->queueLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
+ unmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i));
+ }
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->cmdBufLabelCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels,
+ forUnmarshaling->cmdBufLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
+ unmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i));
+ }
+ }
+ vkStream->read((uint32_t*)&forUnmarshaling->objectCount, sizeof(uint32_t));
+ vkStream->alloc((void**)&forUnmarshaling->pObjects,
+ forUnmarshaling->objectCount * sizeof(const VkDebugUtilsObjectNameInfoEXT));
+ if (forUnmarshaling) {
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
+ unmarshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType,
+ (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i));
+ }
+ }
+}
+
+void marshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkDebugUtilsMessengerCreateFlagsEXT*)&forMarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ vkStream->write((VkDebugUtilsMessageSeverityFlagsEXT*)&forMarshaling->messageSeverity,
+ sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ vkStream->write((VkDebugUtilsMessageTypeFlagsEXT*)&forMarshaling->messageType,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ uint64_t cgen_var_0 = (uint64_t)forMarshaling->pfnUserCallback;
+ vkStream->putBe64(cgen_var_0);
+ // WARNING PTR CHECK
+ uint64_t cgen_var_1 = (uint64_t)(uintptr_t)forMarshaling->pUserData;
+ vkStream->putBe64(cgen_var_1);
+ if (forMarshaling->pUserData) {
+ vkStream->write((void*)forMarshaling->pUserData, sizeof(uint8_t));
+ }
+}
+
+void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkDebugUtilsMessengerCreateFlagsEXT*)&forUnmarshaling->flags,
+ sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ vkStream->read((VkDebugUtilsMessageSeverityFlagsEXT*)&forUnmarshaling->messageSeverity,
+ sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ vkStream->read((VkDebugUtilsMessageTypeFlagsEXT*)&forUnmarshaling->messageType,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ forUnmarshaling->pfnUserCallback = (PFN_vkDebugUtilsMessengerCallbackEXT)vkStream->getBe64();
+ // WARNING PTR CHECK
+ forUnmarshaling->pUserData = (void*)(uintptr_t)vkStream->getBe64();
+ if (forUnmarshaling->pUserData) {
+ vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+ vkStream->read((void*)forUnmarshaling->pUserData, sizeof(uint8_t));
+ }
+}
+
+void marshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling) {
+ (void)rootType;
+ vkStream->write((VkStructureType*)&forMarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forMarshaling->sType;
+ }
+ marshal_extension_struct(vkStream, rootType, forMarshaling->pNext);
+ vkStream->write((VkObjectType*)&forMarshaling->objectType, sizeof(VkObjectType));
+ vkStream->write((uint64_t*)&forMarshaling->objectHandle, sizeof(uint64_t));
+ vkStream->write((uint64_t*)&forMarshaling->tagName, sizeof(uint64_t));
+ uint64_t cgen_var_0 = (uint64_t)forMarshaling->tagSize;
+ vkStream->putBe64(cgen_var_0);
+ vkStream->write((const void*)forMarshaling->pTag,
+ forMarshaling->tagSize * sizeof(const uint8_t));
+}
+
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling) {
+ (void)rootType;
+ vkStream->read((VkStructureType*)&forUnmarshaling->sType, sizeof(VkStructureType));
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ size_t pNext_size;
+ pNext_size = vkStream->getBe32();
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ vkStream->read((void*)forUnmarshaling->pNext, sizeof(VkStructureType));
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ unmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext));
+ }
+ vkStream->read((VkObjectType*)&forUnmarshaling->objectType, sizeof(VkObjectType));
+ vkStream->read((uint64_t*)&forUnmarshaling->objectHandle, sizeof(uint64_t));
+ vkStream->read((uint64_t*)&forUnmarshaling->tagName, sizeof(uint64_t));
+ forUnmarshaling->tagSize = (size_t)vkStream->getBe64();
+ vkStream->alloc((void**)&forUnmarshaling->pTag,
+ forUnmarshaling->tagSize * sizeof(const uint8_t));
+ vkStream->read((void*)forUnmarshaling->pTag, forUnmarshaling->tagSize * sizeof(const uint8_t));
+}
+
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
@@ -18655,6 +18965,20 @@
break;
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ marshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDebugUtilsObjectNameInfoEXT*>(structExtension));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ marshal_VkDebugUtilsMessengerCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<const VkDebugUtilsMessengerCreateInfoEXT*>(structExtension));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
marshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -19899,6 +20223,20 @@
break;
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ unmarshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
unmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -20949,6 +21287,41 @@
return "OP_vkQueueSignalReleaseImageANDROID";
}
#endif
+#ifdef VK_EXT_debug_utils
+ case OP_vkSetDebugUtilsObjectNameEXT: {
+ return "OP_vkSetDebugUtilsObjectNameEXT";
+ }
+ case OP_vkSetDebugUtilsObjectTagEXT: {
+ return "OP_vkSetDebugUtilsObjectTagEXT";
+ }
+ case OP_vkQueueBeginDebugUtilsLabelEXT: {
+ return "OP_vkQueueBeginDebugUtilsLabelEXT";
+ }
+ case OP_vkQueueEndDebugUtilsLabelEXT: {
+ return "OP_vkQueueEndDebugUtilsLabelEXT";
+ }
+ case OP_vkQueueInsertDebugUtilsLabelEXT: {
+ return "OP_vkQueueInsertDebugUtilsLabelEXT";
+ }
+ case OP_vkCmdBeginDebugUtilsLabelEXT: {
+ return "OP_vkCmdBeginDebugUtilsLabelEXT";
+ }
+ case OP_vkCmdEndDebugUtilsLabelEXT: {
+ return "OP_vkCmdEndDebugUtilsLabelEXT";
+ }
+ case OP_vkCmdInsertDebugUtilsLabelEXT: {
+ return "OP_vkCmdInsertDebugUtilsLabelEXT";
+ }
+ case OP_vkCreateDebugUtilsMessengerEXT: {
+ return "OP_vkCreateDebugUtilsMessengerEXT";
+ }
+ case OP_vkDestroyDebugUtilsMessengerEXT: {
+ return "OP_vkDestroyDebugUtilsMessengerEXT";
+ }
+ case OP_vkSubmitDebugUtilsMessageEXT: {
+ return "OP_vkSubmitDebugUtilsMessageEXT";
+ }
+#endif
#ifdef VK_GOOGLE_gfxstream
case OP_vkMapMemoryIntoAddressSpaceGOOGLE: {
return "OP_vkMapMemoryIntoAddressSpaceGOOGLE";
diff --git a/host/vulkan/cereal/common/goldfish_vk_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
index 51a8b16..9690e75 100644
--- a/host/vulkan/cereal/common/goldfish_vk_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_marshaling.h
@@ -3194,6 +3194,51 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void marshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsLabelEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsLabelEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectNameInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCallbackDataEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsMessengerCreateInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling);
+
+void marshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ const VkDebugUtilsObjectTagInfoEXT* forMarshaling);
+
+void unmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling);
+
+#define OP_vkSetDebugUtilsObjectNameEXT 20294
+#define OP_vkSetDebugUtilsObjectTagEXT 20295
+#define OP_vkQueueBeginDebugUtilsLabelEXT 20296
+#define OP_vkQueueEndDebugUtilsLabelEXT 20297
+#define OP_vkQueueInsertDebugUtilsLabelEXT 20298
+#define OP_vkCmdBeginDebugUtilsLabelEXT 20299
+#define OP_vkCmdEndDebugUtilsLabelEXT 20300
+#define OP_vkCmdInsertDebugUtilsLabelEXT 20301
+#define OP_vkCreateDebugUtilsMessengerEXT 20302
+#define OP_vkDestroyDebugUtilsMessengerEXT 20303
+#define OP_vkSubmitDebugUtilsMessageEXT 20304
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
index ba88df5..cdb9f36 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.cpp
@@ -11973,6 +11973,236 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void reservedunmarshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsLabelEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pLabelName, ptr);
+ memcpy((float*)forUnmarshaling->color, *ptr, 4 * sizeof(float));
+ *ptr += 4 * sizeof(float);
+}
+
+void reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream,
+ VkStructureType rootType,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling,
+ uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkObjectType*)&forUnmarshaling->objectType, *ptr, sizeof(VkObjectType));
+ *ptr += sizeof(VkObjectType);
+ memcpy((uint64_t*)&forUnmarshaling->objectHandle, *ptr, sizeof(uint64_t));
+ *ptr += sizeof(uint64_t);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+ // WARNING PTR CHECK
+ memcpy((char**)&forUnmarshaling->pObjectName, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pObjectName);
+ *ptr += 8;
+ if (forUnmarshaling->pObjectName) {
+ vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pObjectName, ptr);
+ }
+ } else {
+ vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pObjectName, ptr);
+ }
+}
+
+void reservedunmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkDebugUtilsMessengerCallbackDataFlagsEXT*)&forUnmarshaling->flags, *ptr,
+ sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT));
+ *ptr += sizeof(VkDebugUtilsMessengerCallbackDataFlagsEXT);
+ if (vkStream->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT) {
+ // WARNING PTR CHECK
+ memcpy((char**)&forUnmarshaling->pMessageIdName, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pMessageIdName);
+ *ptr += 8;
+ if (forUnmarshaling->pMessageIdName) {
+ vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pMessageIdName, ptr);
+ }
+ } else {
+ vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pMessageIdName, ptr);
+ }
+ memcpy((int32_t*)&forUnmarshaling->messageIdNumber, *ptr, sizeof(int32_t));
+ *ptr += sizeof(int32_t);
+ vkStream->loadStringInPlaceWithStreamPtr((char**)&forUnmarshaling->pMessage, ptr);
+ memcpy((uint32_t*)&forUnmarshaling->queueLabelCount, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ vkStream->alloc((void**)&forUnmarshaling->pQueueLabels,
+ forUnmarshaling->queueLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->queueLabelCount; ++i) {
+ reservedunmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pQueueLabels + i), ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->cmdBufLabelCount, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ vkStream->alloc((void**)&forUnmarshaling->pCmdBufLabels,
+ forUnmarshaling->cmdBufLabelCount * sizeof(const VkDebugUtilsLabelEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->cmdBufLabelCount; ++i) {
+ reservedunmarshal_VkDebugUtilsLabelEXT(
+ vkStream, rootType, (VkDebugUtilsLabelEXT*)(forUnmarshaling->pCmdBufLabels + i), ptr);
+ }
+ memcpy((uint32_t*)&forUnmarshaling->objectCount, *ptr, sizeof(uint32_t));
+ *ptr += sizeof(uint32_t);
+ vkStream->alloc((void**)&forUnmarshaling->pObjects,
+ forUnmarshaling->objectCount * sizeof(const VkDebugUtilsObjectNameInfoEXT));
+ for (uint32_t i = 0; i < (uint32_t)forUnmarshaling->objectCount; ++i) {
+ reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType, (VkDebugUtilsObjectNameInfoEXT*)(forUnmarshaling->pObjects + i),
+ ptr);
+ }
+}
+
+void reservedunmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling, uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkDebugUtilsMessengerCreateFlagsEXT*)&forUnmarshaling->flags, *ptr,
+ sizeof(VkDebugUtilsMessengerCreateFlagsEXT));
+ *ptr += sizeof(VkDebugUtilsMessengerCreateFlagsEXT);
+ memcpy((VkDebugUtilsMessageSeverityFlagsEXT*)&forUnmarshaling->messageSeverity, *ptr,
+ sizeof(VkDebugUtilsMessageSeverityFlagsEXT));
+ *ptr += sizeof(VkDebugUtilsMessageSeverityFlagsEXT);
+ memcpy((VkDebugUtilsMessageTypeFlagsEXT*)&forUnmarshaling->messageType, *ptr,
+ sizeof(VkDebugUtilsMessageTypeFlagsEXT));
+ *ptr += sizeof(VkDebugUtilsMessageTypeFlagsEXT);
+ memcpy((PFN_vkDebugUtilsMessengerCallbackEXT*)&forUnmarshaling->pfnUserCallback, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pfnUserCallback);
+ *ptr += 8;
+ // WARNING PTR CHECK
+ memcpy((void**)&forUnmarshaling->pUserData, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->pUserData);
+ *ptr += 8;
+ if (forUnmarshaling->pUserData) {
+ vkStream->alloc((void**)&forUnmarshaling->pUserData, sizeof(uint8_t));
+ memcpy((void*)forUnmarshaling->pUserData, *ptr, sizeof(uint8_t));
+ *ptr += sizeof(uint8_t);
+ }
+}
+
+void reservedunmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream,
+ VkStructureType rootType,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling,
+ uint8_t** ptr) {
+ memcpy((VkStructureType*)&forUnmarshaling->sType, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ if (rootType == VK_STRUCTURE_TYPE_MAX_ENUM) {
+ rootType = forUnmarshaling->sType;
+ }
+ uint32_t pNext_size;
+ memcpy((uint32_t*)&pNext_size, *ptr, sizeof(uint32_t));
+ android::base::Stream::fromBe32((uint8_t*)&pNext_size);
+ *ptr += sizeof(uint32_t);
+ forUnmarshaling->pNext = nullptr;
+ if (pNext_size) {
+ vkStream->alloc((void**)&forUnmarshaling->pNext, sizeof(VkStructureType));
+ memcpy((void*)forUnmarshaling->pNext, *ptr, sizeof(VkStructureType));
+ *ptr += sizeof(VkStructureType);
+ VkStructureType extType = *(VkStructureType*)(forUnmarshaling->pNext);
+ vkStream->alloc((void**)&forUnmarshaling->pNext,
+ goldfish_vk_extension_struct_size_with_stream_features(
+ vkStream->getFeatureBits(), rootType, forUnmarshaling->pNext));
+ *(VkStructureType*)forUnmarshaling->pNext = extType;
+ reservedunmarshal_extension_struct(vkStream, rootType, (void*)(forUnmarshaling->pNext),
+ ptr);
+ }
+ memcpy((VkObjectType*)&forUnmarshaling->objectType, *ptr, sizeof(VkObjectType));
+ *ptr += sizeof(VkObjectType);
+ memcpy((uint64_t*)&forUnmarshaling->objectHandle, *ptr, sizeof(uint64_t));
+ *ptr += sizeof(uint64_t);
+ memcpy((uint64_t*)&forUnmarshaling->tagName, *ptr, sizeof(uint64_t));
+ *ptr += sizeof(uint64_t);
+ memcpy((size_t*)&forUnmarshaling->tagSize, (*ptr), 8);
+ android::base::Stream::fromBe64((uint8_t*)&forUnmarshaling->tagSize);
+ *ptr += 8;
+ vkStream->alloc((void**)&forUnmarshaling->pTag,
+ forUnmarshaling->tagSize * sizeof(const uint8_t));
+ memcpy((void*)forUnmarshaling->pTag, *ptr, forUnmarshaling->tagSize * sizeof(const uint8_t));
+ *ptr += forUnmarshaling->tagSize * sizeof(const uint8_t);
+}
+
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
@@ -14709,6 +14939,20 @@
break;
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out), ptr);
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ reservedunmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ vkStream, rootType,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out), ptr);
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
reservedunmarshal_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
index fd75598..0e497bb 100644
--- a/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
+++ b/host/vulkan/cereal/common/goldfish_vk_reserved_marshaling.h
@@ -1689,6 +1689,27 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void reservedunmarshal_VkDebugUtilsLabelEXT(VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsLabelEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDebugUtilsObjectNameInfoEXT(VulkanStream* vkStream,
+ VkStructureType rootType,
+ VkDebugUtilsObjectNameInfoEXT* forUnmarshaling,
+ uint8_t** ptr);
+
+void reservedunmarshal_VkDebugUtilsMessengerCallbackDataEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCallbackDataEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDebugUtilsMessengerCreateInfoEXT(
+ VulkanStream* vkStream, VkStructureType rootType,
+ VkDebugUtilsMessengerCreateInfoEXT* forUnmarshaling, uint8_t** ptr);
+
+void reservedunmarshal_VkDebugUtilsObjectTagInfoEXT(VulkanStream* vkStream,
+ VkStructureType rootType,
+ VkDebugUtilsObjectTagInfoEXT* forUnmarshaling,
+ uint8_t** ptr);
+
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.cpp b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
index e80c899..9a00b66 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.cpp
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.cpp
@@ -7125,6 +7125,144 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void transform_tohost_VkDebugUtilsLabelEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkDebugUtilsLabelEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkDebugUtilsObjectNameInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkDebugUtilsObjectNameInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pQueueLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->queueLabelCount; ++i) {
+ transform_tohost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pQueueLabels + i));
+ }
+ }
+ }
+ if (toTransform) {
+ if (toTransform->pCmdBufLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->cmdBufLabelCount; ++i) {
+ transform_tohost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pCmdBufLabels + i));
+ }
+ }
+ }
+ if (toTransform) {
+ if (toTransform->pObjects) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->objectCount; ++i) {
+ transform_tohost_VkDebugUtilsObjectNameInfoEXT(
+ resourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(toTransform->pObjects + i));
+ }
+ }
+ }
+}
+
+void transform_fromhost_VkDebugUtilsMessengerCallbackDataEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+ if (toTransform) {
+ if (toTransform->pQueueLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->queueLabelCount; ++i) {
+ transform_fromhost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pQueueLabels + i));
+ }
+ }
+ }
+ if (toTransform) {
+ if (toTransform->pCmdBufLabels) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->cmdBufLabelCount; ++i) {
+ transform_fromhost_VkDebugUtilsLabelEXT(
+ resourceTracker, (VkDebugUtilsLabelEXT*)(toTransform->pCmdBufLabels + i));
+ }
+ }
+ }
+ if (toTransform) {
+ if (toTransform->pObjects) {
+ for (uint32_t i = 0; i < (uint32_t)toTransform->objectCount; ++i) {
+ transform_fromhost_VkDebugUtilsObjectNameInfoEXT(
+ resourceTracker, (VkDebugUtilsObjectNameInfoEXT*)(toTransform->pObjects + i));
+ }
+ }
+ }
+}
+
+void transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_tohost_VkDebugUtilsObjectTagInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_tohost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
+void transform_fromhost_VkDebugUtilsObjectTagInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform) {
+ (void)resourceTracker;
+ (void)toTransform;
+ if (toTransform->pNext) {
+ transform_fromhost_extension_struct(resourceTracker, (void*)(toTransform->pNext));
+ }
+}
+
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
@@ -9097,6 +9235,20 @@
break;
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ transform_tohost_VkDebugUtilsObjectNameInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_tohost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
@@ -10222,6 +10374,20 @@
break;
}
#endif
+#ifdef VK_EXT_debug_utils
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: {
+ transform_fromhost_VkDebugUtilsObjectNameInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugUtilsObjectNameInfoEXT*>(structExtension_out));
+ break;
+ }
+ case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: {
+ transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(
+ resourceTracker,
+ reinterpret_cast<VkDebugUtilsMessengerCreateInfoEXT*>(structExtension_out));
+ break;
+ }
+#endif
#ifdef VK_EXT_vertex_attribute_divisor
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: {
transform_fromhost_VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT(
diff --git a/host/vulkan/cereal/common/goldfish_vk_transform.h b/host/vulkan/cereal/common/goldfish_vk_transform.h
index b7b5851..f8a3894 100644
--- a/host/vulkan/cereal/common/goldfish_vk_transform.h
+++ b/host/vulkan/cereal/common/goldfish_vk_transform.h
@@ -2803,6 +2803,36 @@
#ifdef VK_EXT_queue_family_foreign
#endif
#ifdef VK_EXT_debug_utils
+void transform_tohost_VkDebugUtilsLabelEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform);
+
+void transform_fromhost_VkDebugUtilsLabelEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsLabelEXT* toTransform);
+
+void transform_tohost_VkDebugUtilsObjectNameInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform);
+
+void transform_fromhost_VkDebugUtilsObjectNameInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectNameInfoEXT* toTransform);
+
+void transform_tohost_VkDebugUtilsMessengerCallbackDataEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform);
+
+void transform_fromhost_VkDebugUtilsMessengerCallbackDataEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCallbackDataEXT* toTransform);
+
+void transform_tohost_VkDebugUtilsMessengerCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform);
+
+void transform_fromhost_VkDebugUtilsMessengerCreateInfoEXT(
+ VkDecoderGlobalState* resourceTracker, VkDebugUtilsMessengerCreateInfoEXT* toTransform);
+
+void transform_tohost_VkDebugUtilsObjectTagInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform);
+
+void transform_fromhost_VkDebugUtilsObjectTagInfoEXT(VkDecoderGlobalState* resourceTracker,
+ VkDebugUtilsObjectTagInfoEXT* toTransform);
+
#endif
#ifdef VK_ANDROID_external_memory_android_hardware_buffer
#endif
