icd: Add object handle value unwrapping

icd/CMakeLists.txt

@@ -59,6 +59,8 @@ target_sources(icd PRIVATE
     vksc_descriptor_set_layout.h
     vksc_device.h
     vksc_device.cpp
+    vksc_dispatchable.h
+    vksc_dispatchable.cpp
     vksc_display_emulation.h
     vksc_display_emulation.cpp
     vksc_global.h

icd/generated/vk_command_buffer.cpp

@@ -11,6 +11,8 @@
 
 #include "vk_command_buffer.h"
 #include "vksc_output_struct_sanitizer.h"
+#include "vksc_dispatchable.h"
+#include "icd_pnext_chain_utils.h"
 
 namespace vk {
 

icd/generated/vk_device.cpp

@@ -11,6 +11,8 @@
 
 #include "vk_device.h"
 #include "vksc_output_struct_sanitizer.h"
+#include "vksc_dispatchable.h"
+#include "icd_pnext_chain_utils.h"
 
 namespace vk {
 
@@ -218,7 +220,14 @@ void Device::DestroyPipelineLayout(VkPipelineLayout pipelineLayout, const VkAllo
 }
 VkResult Device::CreateSampler(const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator,
                                VkSampler* pSampler) {
-    return dispatch_table_.CreateSampler(handle_, pCreateInfo, pAllocator, pSampler);
+    auto vk_mod_pCreateInfo = *pCreateInfo;
+    icd::ShadowStack::Frame stack_frame{};
+    icd::ModifiablePNextChain vk_mod_pCreateInfo_pnext_chain(stack_frame, vk_mod_pCreateInfo);
+    if (auto vk_mod_struct = vk_mod_pCreateInfo_pnext_chain.GetStruct<VkDebugUtilsObjectNameInfoEXT>()) {
+        vk_mod_struct->objectHandle = vksc::ConvertVkSCHandleToVulkan(vk_mod_struct->objectType, vk_mod_struct->objectHandle);
+        vk_mod_pCreateInfo.pNext = vk_mod_pCreateInfo_pnext_chain.GetModifiedPNext();
+    }
+    return dispatch_table_.CreateSampler(handle_, &vk_mod_pCreateInfo, pAllocator, pSampler);
 }
 void Device::DestroySampler(VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
     dispatch_table_.DestroySampler(handle_, sampler, pAllocator);
@@ -876,10 +885,14 @@ void Device::SetHdrMetadataEXT(uint32_t swapchainCount, const VkSwapchainKHR* pS
     dispatch_table_.SetHdrMetadataEXT(handle_, swapchainCount, pSwapchains, pMetadata);
 }
 VkResult Device::SetDebugUtilsObjectNameEXT(const VkDebugUtilsObjectNameInfoEXT* pNameInfo) {
-    return dispatch_table_.SetDebugUtilsObjectNameEXT(handle_, pNameInfo);
+    auto vk_mod_pNameInfo = *pNameInfo;
+    vk_mod_pNameInfo.objectHandle = vksc::ConvertVkSCHandleToVulkan(vk_mod_pNameInfo.objectType, vk_mod_pNameInfo.objectHandle);
+    return dispatch_table_.SetDebugUtilsObjectNameEXT(handle_, &vk_mod_pNameInfo);
 }
 VkResult Device::SetDebugUtilsObjectTagEXT(const VkDebugUtilsObjectTagInfoEXT* pTagInfo) {
-    return dispatch_table_.SetDebugUtilsObjectTagEXT(handle_, pTagInfo);
+    auto vk_mod_pTagInfo = *pTagInfo;
+    vk_mod_pTagInfo.objectHandle = vksc::ConvertVkSCHandleToVulkan(vk_mod_pTagInfo.objectType, vk_mod_pTagInfo.objectHandle);
+    return dispatch_table_.SetDebugUtilsObjectTagEXT(handle_, &vk_mod_pTagInfo);
 }
 #ifdef VK_USE_PLATFORM_ANDROID_KHR
 VkResult Device::GetAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer* buffer,
@@ -946,11 +959,25 @@ VkResult Device::GetExecutionGraphPipelineNodeIndexAMDX(VkPipeline executionGrap
 #endif  // VK_ENABLE_BETA_EXTENSIONS
 VkResult Device::WriteSamplerDescriptorsEXT(uint32_t samplerCount, const VkSamplerCreateInfo* pSamplers,
                                             const VkHostAddressRangeEXT* pDescriptors) {
-    return dispatch_table_.WriteSamplerDescriptorsEXT(handle_, samplerCount, pSamplers, pDescriptors);
+    auto vk_mod_pSamplers = *pSamplers;
+    icd::ShadowStack::Frame stack_frame{};
+    icd::ModifiablePNextChain vk_mod_pSamplers_pnext_chain(stack_frame, vk_mod_pSamplers);
+    if (auto vk_mod_struct = vk_mod_pSamplers_pnext_chain.GetStruct<VkDebugUtilsObjectNameInfoEXT>()) {
+        vk_mod_struct->objectHandle = vksc::ConvertVkSCHandleToVulkan(vk_mod_struct->objectType, vk_mod_struct->objectHandle);
+        vk_mod_pSamplers.pNext = vk_mod_pSamplers_pnext_chain.GetModifiedPNext();
+    }
+    return dispatch_table_.WriteSamplerDescriptorsEXT(handle_, samplerCount, &vk_mod_pSamplers, pDescriptors);
 }
 VkResult Device::WriteResourceDescriptorsEXT(uint32_t resourceCount, const VkResourceDescriptorInfoEXT* pResources,
                                              const VkHostAddressRangeEXT* pDescriptors) {
-    return dispatch_table_.WriteResourceDescriptorsEXT(handle_, resourceCount, pResources, pDescriptors);
+    auto vk_mod_pResources = *pResources;
+    icd::ShadowStack::Frame stack_frame{};
+    icd::ModifiablePNextChain vk_mod_pResources_pnext_chain(stack_frame, vk_mod_pResources);
+    if (auto vk_mod_struct = vk_mod_pResources_pnext_chain.GetStruct<VkDebugUtilsObjectNameInfoEXT>()) {
+        vk_mod_struct->objectHandle = vksc::ConvertVkSCHandleToVulkan(vk_mod_struct->objectType, vk_mod_struct->objectHandle);
+        vk_mod_pResources.pNext = vk_mod_pResources_pnext_chain.GetModifiedPNext();
+    }
+    return dispatch_table_.WriteResourceDescriptorsEXT(handle_, resourceCount, &vk_mod_pResources, pDescriptors);
 }
 VkResult Device::GetImageOpaqueCaptureDataEXT(uint32_t imageCount, const VkImage* pImages, VkHostAddressRangeEXT* pDatas) {
     VkResult result = dispatch_table_.GetImageOpaqueCaptureDataEXT(handle_, imageCount, pImages, pDatas);
@@ -1165,10 +1192,12 @@ void Device::DestroyPrivateDataSlotEXT(VkPrivateDataSlot privateDataSlot, const
 }
 VkResult Device::SetPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot,
                                    uint64_t data) {
-    return dispatch_table_.SetPrivateDataEXT(handle_, objectType, objectHandle, privateDataSlot, data);
+    return dispatch_table_.SetPrivateDataEXT(handle_, objectType, vksc::ConvertVkSCHandleToVulkan(objectType, objectHandle),
+                                             privateDataSlot, data);
 }
 void Device::GetPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) {
-    dispatch_table_.GetPrivateDataEXT(handle_, objectType, objectHandle, privateDataSlot, pData);
+    dispatch_table_.GetPrivateDataEXT(handle_, objectType, vksc::ConvertVkSCHandleToVulkan(objectType, objectHandle),
+                                      privateDataSlot, pData);
 }
 #ifdef VK_ENABLE_BETA_EXTENSIONS
 VkResult Device::CreateCudaModuleNV(const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator,

icd/generated/vk_instance.cpp

@@ -11,6 +11,8 @@
 
 #include "vk_instance.h"
 #include "vksc_output_struct_sanitizer.h"
+#include "vksc_dispatchable.h"
+#include "icd_pnext_chain_utils.h"
 
 namespace vk {
 

icd/generated/vk_physical_device.cpp

@@ -11,6 +11,8 @@
 
 #include "vk_physical_device.h"
 #include "vksc_output_struct_sanitizer.h"
+#include "vksc_dispatchable.h"
+#include "icd_pnext_chain_utils.h"
 
 namespace vk {
 

icd/generated/vk_queue.cpp

@@ -11,6 +11,8 @@
 
 #include "vk_queue.h"
 #include "vksc_output_struct_sanitizer.h"
+#include "vksc_dispatchable.h"
+#include "icd_pnext_chain_utils.h"
 
 namespace vk {
 

icd/vksc_dispatchable.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2024-2026 The Khronos Group Inc.
+ * Copyright (c) 2024-2026 RasterGrid Kft.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include "vksc_dispatchable.h"
+
+#include "vksc_instance.h"
+#include "vksc_physical_device.h"
+#include "vksc_device.h"
+#include "vksc_queue.h"
+#include "vksc_command_buffer.h"
+
+namespace vksc {
+
+uint64_t ConvertVkSCHandleToVulkan(VkObjectType object_type, uint64_t object_handle) {
+    if (object_handle == 0) {
+        return 0;
+    }
+
+    switch (object_type) {
+        case VK_OBJECT_TYPE_INSTANCE:
+            return ConvertVkSCHandleToVulkan<Instance, VkInstance>(object_handle);
+
+        case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
+            return ConvertVkSCHandleToVulkan<PhysicalDevice, VkPhysicalDevice>(object_handle);
+
+        case VK_OBJECT_TYPE_DEVICE:
+            return ConvertVkSCHandleToVulkan<Device, VkDevice>(object_handle);
+
+        case VK_OBJECT_TYPE_QUEUE:
+            return ConvertVkSCHandleToVulkan<Queue, VkQueue>(object_handle);
+
+        case VK_OBJECT_TYPE_COMMAND_BUFFER:
+            return ConvertVkSCHandleToVulkan<CommandBuffer, VkCommandBuffer>(object_handle);
+
+        default:
+            return object_handle;
+    }
+}
+
+}  // namespace vksc

icd/vksc_dispatchable.h

@@ -79,4 +79,17 @@ class DispatchableChildren {
     std::unordered_map<HANDLE, std::unique_ptr<OBJ>> children_{};
 };
 
+template <typename OBJ, typename HANDLE>
+uint64_t ConvertVkSCHandleToVulkan(uint64_t object_handle) {
+    if (object_handle != 0) {
+        auto obj = OBJ::FromHandle(reinterpret_cast<HANDLE>(static_cast<uintptr_t>(object_handle)));
+        return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(obj->VkHandle()));
+    } else {
+        // Null handles always convert to null handles
+        return 0;
+    }
+}
+
+uint64_t ConvertVkSCHandleToVulkan(VkObjectType object_type, uint64_t object_handle);
+
 }  // namespace vksc